home *** CD-ROM | disk | FTP | other *** search
/ Workbench Add-On / Workbench Add-On - Volume 1.iso / BBS-Archive / Dev / gcc263-src.lha / gcc-2.6.3 / config / m88k / m88k.h < prev    next >
C/C++ Source or Header  |  1994-09-27  |  101KB  |  2,623 lines

  1. /* Definitions of target machine for GNU compiler for
  2.    Motorola m88100 in an 88open OCS/BCS environment.
  3.    Copyright (C) 1988, 89, 90, 91, 93, 1994 Free Software Foundation, Inc.
  4.    Contributed by Michael Tiemann (tiemann@mcc.com)
  5.    Enhanced by Michael Meissner (meissner@osf.org)
  6.    Version 2 port by Tom Wood (twood@pets.sps.mot.com)
  7.  
  8. This file is part of GNU CC.
  9.  
  10. GNU CC is free software; you can redistribute it and/or modify
  11. it under the terms of the GNU General Public License as published by
  12. the Free Software Foundation; either version 2, or (at your option)
  13. any later version.
  14.  
  15. GNU CC is distributed in the hope that it will be useful,
  16. but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18. GNU General Public License for more details.
  19.  
  20. You should have received a copy of the GNU General Public License
  21. along with GNU CC; see the file COPYING.  If not, write to
  22. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  23.  
  24. /* The m88100 port of GNU CC adheres to the various standards from 88open.
  25.    These documents are available by writing:
  26.  
  27.     88open Consortium Ltd.
  28.     100 Homeland Court, Suite 800
  29.     San Jose, CA  95112
  30.     (408) 436-6600
  31.  
  32.    In brief, the current standards are:
  33.  
  34.    Binary Compatibility Standard, Release 1.1A, May 1991
  35.     This provides for portability of application-level software at the
  36.     executable level for AT&T System V Release 3.2.
  37.  
  38.    Object Compatibility Standard, Release 1.1A, May 1991
  39.     This provides for portability of application-level software at the
  40.     object file and library level for C, Fortran, and Cobol, and again,
  41.     largely for SVR3.
  42.  
  43.    Under development are standards for AT&T System V Release 4, based on the
  44.    [generic] System V Application Binary Interface from AT&T.  These include:
  45.  
  46.    System V Application Binary Interface, Motorola 88000 Processor Supplement
  47.     Another document from AT&T for SVR4 specific to the m88100.
  48.     Available from Prentice Hall.
  49.  
  50.    System V Application Binary Interface, Motorola 88000 Processor Supplement,
  51.    Release 1.1, Draft H, May 6, 1991
  52.     A proposed update to the AT&T document from 88open.
  53.  
  54.    System V ABI Implementation Guide for the M88000 Processor,
  55.    Release 1.0, January 1991
  56.     A companion ABI document from 88open.  */
  57.  
  58. /* Other *.h files in config/m88k include this one and override certain items.
  59.    Currently these are sysv3.h, sysv4.h, dgux.h, dolph.h, tekXD88.h, and luna.h.
  60.    Additionally, sysv4.h and dgux.h include svr4.h first.  All other
  61.    m88k targets except luna.h are based on svr3.h.  */
  62.  
  63. /* Choose SVR3 as the default.  */
  64. #if !defined(DBX_DEBUGGING_INFO) && !defined(DWARF_DEBUGGING_INFO)
  65. #include "svr3.h"
  66. #endif
  67.  
  68. /* External types used.  */
  69.  
  70. /* What instructions are needed to manufacture an integer constant.  */
  71. enum m88k_instruction {
  72.   m88k_zero,
  73.   m88k_or,
  74.   m88k_subu,
  75.   m88k_or_lo16,
  76.   m88k_or_lo8,
  77.   m88k_set,
  78.   m88k_oru_hi16,
  79.   m88k_oru_or
  80. };
  81.  
  82. /* Which processor to schedule for.  The elements of the enumeration
  83.    must match exactly the cpu attribute in the m88k.md machine description. */
  84.  
  85. enum processor_type {
  86.   PROCESSOR_M88100,
  87.   PROCESSOR_M88110,
  88.   PROCESSOR_M88000,
  89. };
  90.  
  91. /* Recast the cpu class to be the cpu attribute.  */
  92. #define m88k_cpu_attr ((enum attr_cpu)m88k_cpu)
  93.  
  94. /* External variables/functions defined in m88k.c.  */
  95.  
  96. extern char *m88k_pound_sign;
  97. extern char *m88k_short_data;
  98. extern char *m88k_version;
  99. extern char m88k_volatile_code;
  100.  
  101. extern unsigned m88k_gp_threshold;
  102. extern int m88k_prologue_done;
  103. extern int m88k_function_number;
  104. extern int m88k_fp_offset;
  105. extern int m88k_stack_size;
  106. extern int m88k_case_index;
  107.  
  108. extern struct rtx_def *m88k_compare_reg;
  109. extern struct rtx_def *m88k_compare_op0;
  110. extern struct rtx_def *m88k_compare_op1;
  111.  
  112. extern enum processor_type m88k_cpu;
  113.  
  114. extern int null_prologue ();
  115. extern int integer_ok_for_set ();
  116. extern int m88k_debugger_offset ();
  117.  
  118. extern void emit_bcnd ();
  119. extern void expand_block_move ();
  120. extern void m88k_layout_frame ();
  121. extern void m88k_expand_prologue ();
  122. extern void m88k_begin_prologue ();
  123. extern void m88k_end_prologue ();
  124. extern void m88k_expand_epilogue ();
  125. extern void m88k_begin_epilogue ();
  126. extern void m88k_end_epilogue ();
  127. extern void output_function_profiler ();
  128. extern void output_function_block_profiler ();
  129. extern void output_block_profiler ();
  130. extern void output_file_start ();
  131. extern void output_ascii ();
  132. extern void output_label ();
  133. extern void print_operand ();
  134. extern void print_operand_address ();
  135.  
  136. extern char *output_load_const_int ();
  137. extern char *output_load_const_float ();
  138. extern char *output_load_const_double ();
  139. extern char *output_load_const_dimode ();
  140. extern char *output_and ();
  141. extern char *output_ior ();
  142. extern char *output_xor ();
  143. extern char *output_call ();
  144.  
  145. extern struct rtx_def *emit_test ();
  146. extern struct rtx_def *legitimize_address ();
  147. extern struct rtx_def *legitimize_operand ();
  148. extern struct rtx_def *m88k_function_arg ();
  149. extern struct rtx_def *m88k_builtin_saveregs ();
  150.  
  151. extern enum m88k_instruction classify_integer ();
  152.  
  153. /* external variables defined elsewhere in the compiler */
  154.  
  155. extern int target_flags;            /* -m compiler switches */
  156. extern int frame_pointer_needed;        /* current function has a FP */
  157. extern int current_function_pretend_args_size;    /* args size without ... */
  158. extern int flag_delayed_branch;            /* -fdelayed-branch */
  159. extern int flag_pic;                /* -fpic */
  160. extern char * reg_names[];
  161.  
  162. /* Specify the default monitors.  The meaning of these values can
  163.    be obtained by doing "grep MONITOR_GCC *m88k*".  Generally, the
  164.    values downward from 0x8000 are tests that will soon go away.
  165.    values upward from 0x1 are generally useful tests that will remain.  */
  166.  
  167. #ifndef MONITOR_GCC
  168. #define MONITOR_GCC 0
  169. #endif
  170.  
  171. /*** Controlling the Compilation Driver, `gcc' ***/
  172. /* Show we can debug even without a frame pointer.  */
  173. #define CAN_DEBUG_WITHOUT_FP
  174.  
  175. /* If -m88100 is in effect, add -D__m88100__; similarly for -m88110.
  176.    Here, the CPU_DEFAULT is assumed to be -m88100.  */
  177. #undef    CPP_SPEC
  178. #define    CPP_SPEC "%{!m88000:%{!m88100:%{m88110:-D__m88110__}}} \
  179.           %{!m88000:%{!m88110:-D__m88100__}}"
  180.  
  181. /* LIB_SPEC, LINK_SPEC, and STARTFILE_SPEC defined in svr3.h.
  182.    ASM_SPEC, ASM_FINAL_SPEC, LIB_SPEC, LINK_SPEC, and STARTFILE_SPEC redefined
  183.    in svr4.h.
  184.    CPP_SPEC, ASM_SPEC, ASM_FINAL_SPEC, LIB_SPEC, LINK_SPEC, and
  185.    STARTFILE_SPEC redefined in dgux.h.  */
  186.  
  187. /*** Run-time Target Specification ***/
  188.  
  189. /* Names to predefine in the preprocessor for this target machine.
  190.    Redefined in sysv3.h, sysv4.h, dgux.h, and luna.h.  */
  191. #define CPP_PREDEFINES "-Dm88000 -Dm88k -Dunix -D__CLASSIFY_TYPE__=2"
  192.  
  193. #define TARGET_VERSION fprintf (stderr, " (%s%s)", \
  194.                 VERSION_INFO1, VERSION_INFO2)
  195.  
  196. /* Print subsidiary information on the compiler version in use.
  197.    Redefined in sysv4.h, and luna.h.  */
  198. #define VERSION_INFO1    "88open OCS/BCS, "
  199. #ifndef VERSION_INFO2
  200. #define VERSION_INFO2   "$Revision: 1.61 $"
  201. #endif
  202.  
  203. #ifndef VERSION_STRING
  204. #define VERSION_STRING  version_string
  205. #ifdef __STDC__
  206. #define TM_RCS_ID      "@(#)" __FILE__ " $Revision: 1.61 $ " __DATE__
  207. #else
  208. #define TM_RCS_ID      "$What$"
  209. #endif  /* __STDC__ */
  210. #else
  211. #define TM_RCS_ID      "@(#)" __FILE__ " " VERSION_INFO2 " " __DATE__
  212. #endif  /* VERSION_STRING */
  213.  
  214. /* Run-time compilation parameters selecting different hardware subsets.  */
  215.  
  216. /* Macro to define tables used to set the flags.
  217.    This is a list in braces of pairs in braces,
  218.    each pair being { "NAME", VALUE }
  219.    where VALUE is the bits to set or minus the bits to clear.
  220.    An empty string NAME is used to identify the default VALUE.  */
  221.  
  222. #define MASK_88100        0x00000001 /* Target m88100 */
  223. #define MASK_88110        0x00000002 /* Target m88110 */
  224. #define MASK_OCS_DEBUG_INFO    0x00000004 /* Emit .tdesc info */
  225. #define MASK_OCS_FRAME_POSITION    0x00000008 /* Debug frame = CFA, not r30 */
  226. #define MASK_SVR4        0x00000010 /* Target is AT&T System V.4 */
  227. #define MASK_SVR3        0x00000020 /* Target is AT&T System V.3 */
  228. #define MASK_NO_UNDERSCORES    0x00000040 /* Don't emit a leading `_' */
  229. #define MASK_BIG_PIC        0x00000080 /* PIC with large got-rel's -fPIC */
  230. #define MASK_TRAP_LARGE_SHIFT    0x00000100 /* Trap if shift not <= 31 */
  231. #define MASK_HANDLE_LARGE_SHIFT    0x00000200 /* Handle shift count >= 32 */
  232. #define MASK_CHECK_ZERO_DIV    0x00000400 /* Check for int div. by 0 */
  233. #define MASK_USE_DIV        0x00000800 /* No signed div. checks */
  234. #define MASK_IDENTIFY_REVISION    0x00001000 /* Emit ident, with GCC rev */
  235. #define MASK_WARN_PASS_STRUCT    0x00002000 /* Warn about passed structs */
  236. #define MASK_OPTIMIZE_ARG_AREA    0x00004000 /* Save stack space */
  237. #define MASK_NO_SERIALIZE_VOLATILE 0x00008000 /* Serialize volatile refs */
  238.  
  239. #define MASK_88000 (MASK_88100 | MASK_88110)
  240. #define MASK_EITHER_LARGE_SHIFT    (MASK_TRAP_LARGE_SHIFT | \
  241.                  MASK_HANDLE_LARGE_SHIFT)
  242.  
  243. #define TARGET_88100            ((target_flags & MASK_88000) == MASK_88100)
  244. #define TARGET_88110         ((target_flags & MASK_88000) == MASK_88110)
  245. #define TARGET_88000         ((target_flags & MASK_88000) == MASK_88000)
  246.  
  247. #define TARGET_OCS_DEBUG_INFO      (target_flags & MASK_OCS_DEBUG_INFO)
  248. #define TARGET_OCS_FRAME_POSITION (target_flags & MASK_OCS_FRAME_POSITION)
  249. #define TARGET_SVR4          (target_flags & MASK_SVR4)
  250. #define TARGET_SVR3          (target_flags & MASK_SVR3)
  251. #define TARGET_NO_UNDERSCORES      (target_flags & MASK_NO_UNDERSCORES)
  252. #define TARGET_BIG_PIC          (target_flags & MASK_BIG_PIC)
  253. #define TARGET_TRAP_LARGE_SHIFT   (target_flags & MASK_TRAP_LARGE_SHIFT)
  254. #define TARGET_HANDLE_LARGE_SHIFT (target_flags & MASK_HANDLE_LARGE_SHIFT)
  255. #define TARGET_CHECK_ZERO_DIV      (target_flags & MASK_CHECK_ZERO_DIV)
  256. #define    TARGET_USE_DIV          (target_flags & MASK_USE_DIV)
  257. #define TARGET_IDENTIFY_REVISION  (target_flags & MASK_IDENTIFY_REVISION)
  258. #define TARGET_WARN_PASS_STRUCT   (target_flags & MASK_WARN_PASS_STRUCT)
  259. #define TARGET_OPTIMIZE_ARG_AREA  (target_flags & MASK_OPTIMIZE_ARG_AREA)
  260. #define TARGET_SERIALIZE_VOLATILE (!(target_flags & MASK_NO_SERIALIZE_VOLATILE))
  261.  
  262. #define TARGET_EITHER_LARGE_SHIFT (target_flags & MASK_EITHER_LARGE_SHIFT)
  263.  
  264. /*  Redefined in sysv3.h, sysv4.h, and dgux.h.  */
  265. #define TARGET_DEFAULT    (MASK_CHECK_ZERO_DIV)
  266. #define CPU_DEFAULT MASK_88100
  267.  
  268. #define TARGET_SWITCHES \
  269.   { \
  270.     { "88110",                 MASK_88110 }, \
  271.     { "88100",                 MASK_88100 }, \
  272.     { "88000",                     MASK_88000 }, \
  273.     { "ocs-debug-info",             MASK_OCS_DEBUG_INFO }, \
  274.     { "no-ocs-debug-info",        -MASK_OCS_DEBUG_INFO }, \
  275.     { "ocs-frame-position",         MASK_OCS_FRAME_POSITION }, \
  276.     { "no-ocs-frame-position",        -MASK_OCS_FRAME_POSITION }, \
  277.     { "svr4",                     MASK_SVR4 }, \
  278.     { "svr3",                    -MASK_SVR4 }, \
  279.     { "no-underscores",             MASK_NO_UNDERSCORES }, \
  280.     { "big-pic",             MASK_BIG_PIC }, \
  281.     { "trap-large-shift",         MASK_TRAP_LARGE_SHIFT }, \
  282.     { "handle-large-shift",         MASK_HANDLE_LARGE_SHIFT }, \
  283.     { "check-zero-division",         MASK_CHECK_ZERO_DIV }, \
  284.     { "no-check-zero-division",        -MASK_CHECK_ZERO_DIV }, \
  285.     { "use-div-instruction",         MASK_USE_DIV }, \
  286.     { "identify-revision",         MASK_IDENTIFY_REVISION }, \
  287.     { "warn-passed-structs",         MASK_WARN_PASS_STRUCT }, \
  288.     { "optimize-arg-area",         MASK_OPTIMIZE_ARG_AREA }, \
  289.     { "no-optimize-arg-area",        -MASK_OPTIMIZE_ARG_AREA }, \
  290.     { "no-serialize-volatile",         MASK_NO_SERIALIZE_VOLATILE }, \
  291.     { "serialize-volatile",        -MASK_NO_SERIALIZE_VOLATILE }, \
  292.     SUBTARGET_SWITCHES \
  293.     /* Default switches */ \
  294.     { "",                 TARGET_DEFAULT }, \
  295.   }
  296.  
  297. /* Redefined in dgux.h.  */
  298. #define SUBTARGET_SWITCHES
  299.  
  300. /* Macro to define table for command options with values.  */
  301.  
  302. #define TARGET_OPTIONS { { "short-data-", &m88k_short_data }, \
  303.              { "version-", &m88k_version } }
  304.  
  305. /* Do any checking or such that is needed after processing the -m switches.  */
  306.  
  307. #define OVERRIDE_OPTIONS                             \
  308.   do {                                         \
  309.     register int i;                                 \
  310.                                          \
  311.     if ((target_flags & MASK_88000) == 0)                     \
  312.       target_flags |= CPU_DEFAULT;                         \
  313.                                          \
  314.     if (TARGET_88110)                                 \
  315.       {                                         \
  316.         target_flags |= MASK_USE_DIV;                         \
  317.         target_flags &= ~MASK_CHECK_ZERO_DIV;                     \
  318.       }                                         \
  319.                                                \
  320.     m88k_cpu = (TARGET_88000 ? PROCESSOR_M88000                     \
  321.         : (TARGET_88100 ? PROCESSOR_M88100 : PROCESSOR_M88110));             \
  322.                                          \
  323.     if (TARGET_BIG_PIC)                                 \
  324.       flag_pic = 2;                                 \
  325.                                          \
  326.     if ((target_flags & MASK_EITHER_LARGE_SHIFT) == MASK_EITHER_LARGE_SHIFT) \
  327.       error ("-mtrap-large-shift and -mhandle-large-shift are incompatible");\
  328.                                          \
  329.     if (TARGET_SVR4)                                      \
  330.       {                                         \
  331.     for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)                 \
  332.       reg_names[i]--;                             \
  333.     m88k_pound_sign = "#";                             \
  334.       }                                         \
  335.     else                                     \
  336.       {                                         \
  337.     target_flags |= MASK_SVR3;                         \
  338.     target_flags &= ~MASK_SVR4;                         \
  339.       }                                         \
  340.                                          \
  341.     if (m88k_short_data)                             \
  342.       {                                         \
  343.     char *p = m88k_short_data;                         \
  344.     while (*p)                                 \
  345.       if (*p >= '0' && *p <= '9')                         \
  346.         p++;                                 \
  347.       else                                     \
  348.         {                                     \
  349.           error ("Invalid option `-mshort-data-%s'", m88k_short_data);   \
  350.           break;                                 \
  351.         }                                     \
  352.     m88k_gp_threshold = atoi (m88k_short_data);                 \
  353.     if (m88k_gp_threshold > 0x7fffffff)                     \
  354.       error ("-mshort-data-%s is too large ", m88k_short_data);          \
  355.     if (flag_pic)                                 \
  356.       error ("-mshort-data-%s and PIC are incompatible", m88k_short_data); \
  357.       }                                         \
  358.   } while (0)
  359.  
  360. /*** Storage Layout ***/
  361.  
  362. /* Sizes in bits of the various types.  */
  363. #define CHAR_TYPE_SIZE         8
  364. #define SHORT_TYPE_SIZE        16
  365. #define INT_TYPE_SIZE        32
  366. #define LONG_TYPE_SIZE        32
  367. #define LONG_LONG_TYPE_SIZE    64
  368. #define FLOAT_TYPE_SIZE        32
  369. #define    DOUBLE_TYPE_SIZE    64
  370. #define LONG_DOUBLE_TYPE_SIZE    64
  371.  
  372. /* Define this if most significant bit is lowest numbered
  373.    in instructions that operate on numbered bit-fields.
  374.    Somewhat arbitrary.  It matches the bit field patterns.  */
  375. #define BITS_BIG_ENDIAN 1
  376.  
  377. /* Define this if most significant byte of a word is the lowest numbered.
  378.    That is true on the m88000.  */
  379. #define BYTES_BIG_ENDIAN 1
  380.  
  381. /* Define this if most significant word of a multiword number is the lowest
  382.    numbered.
  383.    For the m88000 we can decide arbitrarily since there are no machine
  384.    instructions for them.  */
  385. #define WORDS_BIG_ENDIAN 1
  386.  
  387. /* Number of bits in an addressable storage unit */
  388. #define BITS_PER_UNIT 8
  389.  
  390. /* Width in bits of a "word", which is the contents of a machine register.
  391.    Note that this is not necessarily the width of data type `int';
  392.    if using 16-bit ints on a 68000, this would still be 32.
  393.    But on a machine with 16-bit registers, this would be 16.  */
  394. #define BITS_PER_WORD 32
  395.  
  396. /* Width of a word, in units (bytes).  */
  397. #define UNITS_PER_WORD 4
  398.  
  399. /* Width in bits of a pointer.
  400.    See also the macro `Pmode' defined below.  */
  401. #define POINTER_SIZE 32
  402.  
  403. /* Allocation boundary (in *bits*) for storing arguments in argument list.  */
  404. #define PARM_BOUNDARY 32
  405.  
  406. /* Largest alignment for stack parameters (if greater than PARM_BOUNDARY).  */
  407. #define MAX_PARM_BOUNDARY 64
  408.  
  409. /* Boundary (in *bits*) on which stack pointer should be aligned.  */
  410. #define STACK_BOUNDARY 128
  411.  
  412. /* Allocation boundary (in *bits*) for the code of a function.  On the
  413.    m88100, it is desirable to align to a cache line.  However, SVR3 targets
  414.    only provided 8 byte alignment.  The m88110 cache is small, so align
  415.    to an 8 byte boundary.  Pack code tightly when compiling crtstuff.c.  */
  416. #define FUNCTION_BOUNDARY (flag_inhibit_size_directive ? 32 : \
  417.                (TARGET_88100 && TARGET_SVR4 ? 128 : 64))
  418.  
  419. /* No data type wants to be aligned rounder than this.  */
  420. #define BIGGEST_ALIGNMENT 64
  421.  
  422. /* The best alignment to use in cases where we have a choice.  */
  423. #define FASTEST_ALIGNMENT (TARGET_88100 ? 32 : 64)
  424.  
  425. /* Make strings 4/8 byte aligned so strcpy from constants will be faster.  */
  426. #define CONSTANT_ALIGNMENT(EXP, ALIGN)  \
  427.   ((TREE_CODE (EXP) == STRING_CST    \
  428.     && (ALIGN) < FASTEST_ALIGNMENT)    \
  429.    ? FASTEST_ALIGNMENT : (ALIGN))
  430.  
  431. /* Make arrays of chars 4/8 byte aligned for the same reasons.  */
  432. #define DATA_ALIGNMENT(TYPE, ALIGN)        \
  433.   (TREE_CODE (TYPE) == ARRAY_TYPE        \
  434.    && TYPE_MODE (TREE_TYPE (TYPE)) == QImode    \
  435.    && (ALIGN) < FASTEST_ALIGNMENT ? FASTEST_ALIGNMENT : (ALIGN))
  436.  
  437. /* Alignment of field after `int : 0' in a structure.
  438.    Ignored with PCC_BITFIELD_TYPE_MATTERS.  */
  439. /* #define EMPTY_FIELD_BOUNDARY 8 */
  440.  
  441. /* Every structure's size must be a multiple of this.  */
  442. #define STRUCTURE_SIZE_BOUNDARY 8
  443.  
  444. /* Set this nonzero if move instructions will actually fail to work
  445.    when given unaligned data.  */
  446. #define STRICT_ALIGNMENT 1
  447.  
  448. /* A bitfield declared as `int' forces `int' alignment for the struct.  */
  449. #define PCC_BITFIELD_TYPE_MATTERS 1
  450.  
  451. /* Maximum size (in bits) to use for the largest integral type that
  452.    replaces a BLKmode type. */
  453. /* #define MAX_FIXED_MODE_SIZE 0 */
  454.  
  455. /* Check a `double' value for validity for a particular machine mode.
  456.    This is defined to avoid crashes outputting certain constants.
  457.    Since we output the number in hex, the assembler won't choke on it.  */
  458. /* #define CHECK_FLOAT_VALUE(MODE,VALUE) */
  459.  
  460. /* A code distinguishing the floating point format of the target machine.  */
  461. /* #define TARGET_FLOAT_FORMAT IEEE_FLOAT_FORMAT */
  462.  
  463. /*** Register Usage ***/
  464.  
  465. /* Number of actual hardware registers.
  466.    The hardware registers are assigned numbers for the compiler
  467.    from 0 to just below FIRST_PSEUDO_REGISTER.
  468.    All registers that the compiler knows about must be given numbers,
  469.    even those that are not normally considered general registers.
  470.  
  471.    The m88100 has a General Register File (GRF) of 32 32-bit registers.
  472.    The m88110 adds an Extended Register File (XRF) of 32 80-bit registers.  */
  473. #define FIRST_PSEUDO_REGISTER 64
  474. #define FIRST_EXTENDED_REGISTER 32
  475.  
  476. /*  General notes on extended registers, their use and misuse.
  477.  
  478.     Possible good uses:
  479.  
  480.     spill area instead of memory.
  481.       -waste if only used once
  482.  
  483.     floating point calculations
  484.       -probably a waste unless we have run out of general purpose registers
  485.  
  486.     freeing up general purpose registers
  487.       -e.g. may be able to have more loop invariants if floating
  488.        point is moved into extended registers.
  489.  
  490.  
  491.     I've noticed wasteful moves into and out of extended registers; e.g. a load
  492.     into x21, then inside a loop a move into r24, then r24 used as input to
  493.     an fadd.  Why not just load into r24 to begin with?  Maybe the new cse.c
  494.     will address this.  This wastes a move, but the load,store and move could
  495.     have been saved had extended registers been used throughout.
  496.     E.g. in the code following code, if z and xz are placed in extended
  497.     registers, there is no need to save preserve registers.
  498.  
  499.     long c=1,d=1,e=1,f=1,g=1,h=1,i=1,j=1,k;
  500.  
  501.     double z=0,xz=4.5;
  502.  
  503.     foo(a,b)
  504.     long a,b;
  505.     {
  506.       while (a < b)
  507.         {
  508.           k = b + c + d + e + f + g + h + a + i + j++;
  509.           z += xz;
  510.           a++;
  511.         }
  512.       printf("k= %d; z=%f;\n", k, z);
  513.     }
  514.  
  515.     I've found that it is possible to change the constraints (putting * before
  516.     the 'r' constraints int the fadd.ddd instruction) and get the entire
  517.     addition and store to go into extended registers.  However, this also
  518.     forces simple addition and return of floating point arguments to a
  519.     function into extended registers.  Not the correct solution.
  520.  
  521.     Found the following note in local-alloc.c which may explain why I can't
  522.     get both registers to be in extended registers since two are allocated in
  523.     local-alloc and one in global-alloc.  Doesn't explain (I don't believe)
  524.     why an extended register is used instead of just using the preserve
  525.     register.
  526.  
  527.     from local-alloc.c:
  528.     We have provision to exempt registers, even when they are contained
  529.     within the block, that can be tied to others that are not contained in it.
  530.     This is so that global_alloc could process them both and tie them then.
  531.     But this is currently disabled since tying in global_alloc is not
  532.     yet implemented.
  533.  
  534.     The explanation of why the preserved register is not used is as follows,
  535.     I believe.  The registers are being allocated in order.  Tying is not
  536.     done so efficiently, so when it comes time to do the first allocation,
  537.     there are no registers left to use without spilling except extended
  538.     registers.  Then when the next pseudo register needs a hard reg, there
  539.     are still no registers to be had for free, but this one must be a GRF
  540.     reg instead of an extended reg, so a preserve register is spilled.  Thus
  541.     the move from extended to GRF is necessitated.  I do not believe this can
  542.     be 'fixed' through the config/*m88k* files.
  543.  
  544.     gcc seems to sometimes make worse use of register allocation -- not counting
  545.     moves -- whenever extended registers are present.  For example in the
  546.     whetstone, the simple for loop (slightly modified)
  547.       for(i = 1; i <= n1; i++)
  548.     {
  549.       x1 = (x1 + x2 + x3 - x4) * t;
  550.       x2 = (x1 + x2 - x3 + x4) * t;
  551.       x3 = (x1 - x2 + x3 + x4) * t;
  552.       x4 = (x1 + x2 + x3 + x4) * t;
  553.     }
  554.     in general loads the high bits of the addresses of x2-x4 and i into registers
  555.     outside the loop.  Whenever extended registers are used, it loads all of
  556.     these inside the loop. My conjecture is that since the 88110 has so many
  557.     registers, and gcc makes no distinction at this point -- just that they are
  558.     not fixed, that in loop.c it believes it can expect a number of registers
  559.     to be available.  Then it allocates 'too many' in local-alloc which causes
  560.     problems later.  'Too many' are allocated because a large portion of the
  561.     registers are extended registers and cannot be used for certain purposes
  562.     ( e.g. hold the address of a variable).  When this loop is compiled on its
  563.     own, the problem does not occur.  I don't know the solution yet, though it
  564.     is probably in the base sources.  Possibly a different way to calculate
  565.     "threshold".  */
  566.  
  567. /* 1 for registers that have pervasive standard uses and are not available
  568.    for the register allocator.  Registers r14-r25 and x22-x29 are expected
  569.    to be preserved across function calls.
  570.  
  571.    On the 88000, the standard uses of the General Register File (GRF) are:
  572.    Reg 0    = Pseudo argument pointer (hardware fixed to 0).
  573.    Reg 1    = Subroutine return pointer (hardware).
  574.    Reg 2-9    = Parameter registers (OCS).
  575.    Reg 10    = OCS reserved temporary.
  576.    Reg 11    = Static link if needed [OCS reserved temporary].
  577.    Reg 12    = Address of structure return (OCS).
  578.    Reg 13    = OCS reserved temporary.
  579.    Reg 14-25    = Preserved register set.
  580.    Reg 26-29    = Reserved by OCS and ABI.
  581.    Reg 30    = Frame pointer (Common use).
  582.    Reg 31    = Stack pointer.
  583.  
  584.    The following follows the current 88open UCS specification for the
  585.    Extended Register File (XRF):
  586.    Reg 32       = x0        Always equal to zero
  587.    Reg 33-53    = x1-x21    Temporary registers (Caller Save)
  588.    Reg 54-61    = x22-x29    Preserver registers (Callee Save)
  589.    Reg 62-63    = x30-x31    Reserved for future ABI use.
  590.  
  591.    Note:  The current 88110 extended register mapping is subject to change.
  592.       The bias towards caller-save registers is based on the
  593.       presumption that memory traffic can potentially be reduced by
  594.       allowing the "caller" to save only that part of the register
  595.       which is actually being used.  (i.e. don't do a st.x if a st.d
  596.       is sufficient).  Also, in scientific code (a.k.a. Fortran), the
  597.       large number of variables defined in common blocks may require
  598.       that almost all registers be saved across calls anyway.  */
  599.  
  600. #define FIXED_REGISTERS \
  601.  {1, 0, 0, 0,  0, 0, 0, 0,   0, 0, 0, 0,  0, 0, 0, 0, \
  602.   0, 0, 0, 0,  0, 0, 0, 0,   0, 0, 1, 1,  1, 1, 1, 1, \
  603.   1, 0, 0, 0,  0, 0, 0, 0,   0, 0, 0, 0,  0, 0, 0, 0, \
  604.   0, 0, 0, 0,  0, 0, 0, 0,   0, 0, 0, 0,  0, 0, 1, 1}
  605.  
  606. /* 1 for registers not available across function calls.
  607.    These must include the FIXED_REGISTERS and also any
  608.    registers that can be used without being saved.
  609.    The latter must include the registers where values are returned
  610.    and the register where structure-value addresses are passed.
  611.    Aside from that, you can include as many other registers as you like.  */
  612.  
  613. #define CALL_USED_REGISTERS \
  614.  {1, 1, 1, 1,  1, 1, 1, 1,   1, 1, 1, 1,  1, 1, 0, 0, \
  615.   0, 0, 0, 0,  0, 0, 0, 0,   0, 0, 1, 1,  1, 1, 1, 1, \
  616.   1, 1, 1, 1,  1, 1, 1, 1,   1, 1, 1, 1,  1, 1, 1, 1, \
  617.   1, 1, 1, 1,  1, 1, 0, 0,   0, 0, 0, 0,  0, 0, 1, 1}
  618.  
  619. /* Macro to conditionally modify fixed_regs/call_used_regs.  */
  620. #define CONDITIONAL_REGISTER_USAGE            \
  621.   {                            \
  622.     if (! TARGET_88110)                    \
  623.       {                            \
  624.     register int i;                    \
  625.       for (i = FIRST_EXTENDED_REGISTER; i < FIRST_PSEUDO_REGISTER; i++) \
  626.         {                        \
  627.           fixed_regs[i] = 1;            \
  628.           call_used_regs[i] = 1;            \
  629.         }                        \
  630.       }                            \
  631.     if (flag_pic)                    \
  632.       {                            \
  633.     /* Current hack to deal with -fpic -O2 problems.  */ \
  634.     fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1;    \
  635.     call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1;    \
  636.     global_regs[PIC_OFFSET_TABLE_REGNUM] = 1;    \
  637.       }                            \
  638.   }
  639.  
  640. /* These interfaces that don't apply to the m88000.  */
  641. /* OVERLAPPING_REGNO_P(REGNO) 0 */
  642. /* INSN_CLOBBERS_REGNO_P(INSN, REGNO) 0 */
  643. /* PRESERVE_DEATH_INFO_REGNO_P(REGNO) 0 */
  644.  
  645. /* True if register is an extended register.  */
  646. #define XRF_REGNO_P(N) ((N) < FIRST_PSEUDO_REGISTER && (N) >= FIRST_EXTENDED_REGISTER)
  647.  
  648. /* Return number of consecutive hard regs needed starting at reg REGNO
  649.    to hold something of mode MODE.
  650.    This is ordinarily the length in words of a value of mode MODE
  651.    but can be less for certain modes in special long registers.
  652.  
  653.    On the m88000, GRF registers hold 32-bits and XRF registers hold 80-bits.
  654.    An XRF register can hold any mode, but two GRF registers are required
  655.    for larger modes.  */
  656. #define HARD_REGNO_NREGS(REGNO, MODE)                    \
  657.   (XRF_REGNO_P (REGNO)                                                 \
  658.    ? 1 : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD))
  659.  
  660. /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE.
  661.  
  662.    For double integers, we never put the value into an odd register so that
  663.    the operators don't run into the situation where the high part of one of
  664.    the inputs is the low part of the result register.  (It's ok if the output
  665.    registers are the same as the input registers.)  The XRF registers can
  666.    hold all modes, but only DF and SF modes can be manipulated in these
  667.    registers.  The compiler should be allowed to use these as a fast spill
  668.    area.  */
  669. #define HARD_REGNO_MODE_OK(REGNO, MODE)                    \
  670.   (XRF_REGNO_P(REGNO)                            \
  671.     ? (TARGET_88110 && GET_MODE_CLASS (MODE) == MODE_FLOAT)             \
  672.     : (((MODE) != DImode && (MODE) != DFmode && (MODE) != DCmode)    \
  673.        || ((REGNO) & 1) == 0))
  674.  
  675. /* Value is 1 if it is a good idea to tie two pseudo registers
  676.    when one has mode MODE1 and one has mode MODE2.
  677.    If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2,
  678.    for any hard reg, then this must be 0 for correct output.  */
  679. #define MODES_TIEABLE_P(MODE1, MODE2) \
  680.   (((MODE1) == DFmode || (MODE1) == DCmode || (MODE1) == DImode \
  681.     || (TARGET_88110 && GET_MODE_CLASS (MODE1) == MODE_FLOAT)) \
  682.    == ((MODE2) == DFmode || (MODE2) == DCmode || (MODE2) == DImode \
  683.        || (TARGET_88110 && GET_MODE_CLASS (MODE2) == MODE_FLOAT)))
  684.  
  685. /* Specify the registers used for certain standard purposes.
  686.    The values of these macros are register numbers.  */
  687.  
  688. /* the m88000 pc isn't overloaded on a register that the compiler knows about.  */
  689. /* #define PC_REGNUM  */
  690.  
  691. /* Register to use for pushing function arguments.  */
  692. #define STACK_POINTER_REGNUM 31
  693.  
  694. /* Base register for access to local variables of the function.  */
  695. #define FRAME_POINTER_REGNUM 30
  696.  
  697. /* Base register for access to arguments of the function.  */
  698. #define ARG_POINTER_REGNUM 0
  699.  
  700. /* Register used in cases where a temporary is known to be safe to use.  */
  701. #define TEMP_REGNUM 10
  702.  
  703. /* Register in which static-chain is passed to a function.  */
  704. #define STATIC_CHAIN_REGNUM 11
  705.  
  706. /* Register in which address to store a structure value
  707.    is passed to a function.  */
  708. #define STRUCT_VALUE_REGNUM 12
  709.  
  710. /* Register to hold the addressing base for position independent
  711.    code access to data items.  */
  712. #define PIC_OFFSET_TABLE_REGNUM 25
  713.  
  714. /* Order in which registers are preferred (most to least).  Use temp
  715.    registers, then param registers top down.  Preserve registers are
  716.    top down to maximize use of double memory ops for register save.
  717.    The 88open reserved registers (r26-r29 and x30-x31) may commonly be used
  718.    in most environments with the -fcall-used- or -fcall-saved- options.  */
  719. #define REG_ALLOC_ORDER          \
  720.  {                  \
  721.   13, 12, 11, 10, 29, 28, 27, 26, \
  722.   62, 63,  9,  8,  7,  6,  5,  4, \
  723.    3,  2,  1, 53, 52, 51, 50, 49, \
  724.   48, 47, 46, 45, 44, 43, 42, 41, \
  725.   40, 39, 38, 37, 36, 35, 34, 33, \
  726.   25, 24, 23, 22, 21, 20, 19, 18, \
  727.   17, 16, 15, 14, 61, 60, 59, 58, \
  728.   57, 56, 55, 54, 30, 31,  0, 32}
  729.  
  730. /* Order for leaf functions.  */
  731. #define REG_LEAF_ALLOC_ORDER      \
  732.  {                  \
  733.    9,  8,  7,  6, 13, 12, 11, 10, \
  734.   29, 28, 27, 26, 62, 63,  5,  4, \
  735.    3,  2,  0, 53, 52, 51, 50, 49, \
  736.   48, 47, 46, 45, 44, 43, 42, 41, \
  737.   40, 39, 38, 37, 36, 35, 34, 33, \
  738.   25, 24, 23, 22, 21, 20, 19, 18, \
  739.   17, 16, 15, 14, 61, 60, 59, 58, \
  740.   57, 56, 55, 54, 30, 31,  1, 32}
  741.  
  742. /* Switch between the leaf and non-leaf orderings.  The purpose is to avoid
  743.    write-over scoreboard delays between caller and callee.  */
  744. #define ORDER_REGS_FOR_LOCAL_ALLOC                \
  745. {                                \
  746.   static int leaf[] = REG_LEAF_ALLOC_ORDER;            \
  747.   static int nonleaf[] = REG_ALLOC_ORDER;            \
  748.                                 \
  749.   bcopy (regs_ever_live[1] ? nonleaf : leaf, reg_alloc_order,    \
  750.      FIRST_PSEUDO_REGISTER * sizeof (int));            \
  751. }
  752.  
  753. /*** Register Classes ***/
  754.  
  755. /* Define the classes of registers for register constraints in the
  756.    machine description.  Also define ranges of constants.
  757.  
  758.    One of the classes must always be named ALL_REGS and include all hard regs.
  759.    If there is more than one class, another class must be named NO_REGS
  760.    and contain no registers.
  761.  
  762.    The name GENERAL_REGS must be the name of a class (or an alias for
  763.    another name such as ALL_REGS).  This is the class of registers
  764.    that is allowed by "g" or "r" in a register constraint.
  765.    Also, registers outside this class are allocated only when
  766.    instructions express preferences for them.
  767.  
  768.    The classes must be numbered in nondecreasing order; that is,
  769.    a larger-numbered class must never be contained completely
  770.    in a smaller-numbered class.
  771.  
  772.    For any two classes, it is very desirable that there be another
  773.    class that represents their union.  */
  774.  
  775. /* The m88000 hardware has two kinds of registers.  In addition, we denote
  776.    the arg pointer as a separate class.  */
  777.  
  778. enum reg_class { NO_REGS, AP_REG, XRF_REGS, GENERAL_REGS, AGRF_REGS,
  779.          XGRF_REGS, ALL_REGS, LIM_REG_CLASSES };
  780.  
  781. #define N_REG_CLASSES (int) LIM_REG_CLASSES
  782.  
  783. /* Give names of register classes as strings for dump file.   */
  784. #define REG_CLASS_NAMES {"NO_REGS", "AP_REG", "XRF_REGS", "GENERAL_REGS", \
  785.              "AGRF_REGS", "XGRF_REGS", "ALL_REGS" }
  786.  
  787. /* Define which registers fit in which classes.
  788.    This is an initializer for a vector of HARD_REG_SET
  789.    of length N_REG_CLASSES.  */
  790. #define REG_CLASS_CONTENTS {{0x00000000, 0x00000000},    \
  791.                 {0x00000001, 0x00000000},    \
  792.                 {0x00000000, 0xffffffff},    \
  793.                 {0xfffffffe, 0x00000000},    \
  794.                 {0xffffffff, 0x00000000},    \
  795.                 {0xfffffffe, 0xffffffff},    \
  796.                 {0xffffffff, 0xffffffff}}
  797.  
  798. /* The same information, inverted:
  799.    Return the class number of the smallest class containing
  800.    reg number REGNO.  This could be a conditional expression
  801.    or could index an array.  */
  802. #define REGNO_REG_CLASS(REGNO) \
  803.   ((REGNO) ? ((REGNO < 32) ? GENERAL_REGS : XRF_REGS) : AP_REG)
  804.  
  805. /* The class value for index registers, and the one for base regs.  */
  806. #define BASE_REG_CLASS AGRF_REGS
  807. #define INDEX_REG_CLASS GENERAL_REGS
  808.  
  809. /* Get reg_class from a letter such as appears in the machine description.
  810.    For the 88000, the following class/letter is defined for the XRF:
  811.     x - Extended register file  */
  812. #define REG_CLASS_FROM_LETTER(C)     \
  813.    (((C) == 'x') ? XRF_REGS : NO_REGS)
  814.  
  815. /* Macros to check register numbers against specific register classes.
  816.    These assume that REGNO is a hard or pseudo reg number.
  817.    They give nonzero only if REGNO is a hard reg of the suitable class
  818.    or a pseudo reg currently allocated to a suitable hard reg.
  819.    Since they use reg_renumber, they are safe only once reg_renumber
  820.    has been allocated, which happens in local-alloc.c.  */
  821. #define REGNO_OK_FOR_BASE_P(REGNO)                \
  822.   ((REGNO) < FIRST_EXTENDED_REGISTER                \
  823.    || (unsigned) reg_renumber[REGNO] < FIRST_EXTENDED_REGISTER)
  824. #define REGNO_OK_FOR_INDEX_P(REGNO)                \
  825.   (((REGNO) && (REGNO) < FIRST_EXTENDED_REGISTER)        \
  826.    || (unsigned) reg_renumber[REGNO] < FIRST_EXTENDED_REGISTER)
  827.  
  828. /* Given an rtx X being reloaded into a reg required to be
  829.    in class CLASS, return the class of reg to actually use.
  830.    In general this is just CLASS; but on some machines
  831.    in some cases it is preferable to use a more restrictive class.
  832.    Double constants should be in a register iff they can be made cheaply.  */
  833. #define PREFERRED_RELOAD_CLASS(X,CLASS)    \
  834.    (CONSTANT_P(X) && (CLASS == XRF_REGS) ? NO_REGS : (CLASS))
  835.  
  836. /* Return the register class of a scratch register needed to load IN
  837.    into a register of class CLASS in MODE.  On the m88k, when PIC, we
  838.    need a temporary when loading some addresses into a register.  */
  839. #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, IN)        \
  840.   ((flag_pic                            \
  841.     && GET_CODE (IN) == CONST                    \
  842.     && GET_CODE (XEXP (IN, 0)) == PLUS                \
  843.     && GET_CODE (XEXP (XEXP (IN, 0), 0)) == CONST_INT        \
  844.     && ! SMALL_INT (XEXP (XEXP (IN, 0), 1))) ? GENERAL_REGS : NO_REGS)
  845.  
  846. /* Return the maximum number of consecutive registers
  847.    needed to represent mode MODE in a register of class CLASS.  */
  848. #define CLASS_MAX_NREGS(CLASS, MODE) \
  849.   ((((CLASS) == XRF_REGS) ? 1 \
  850.     : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)))
  851.  
  852. /* Letters in the range `I' through `P' in a register constraint string can
  853.    be used to stand for particular ranges of immediate operands.  The C
  854.    expression is true iff C is a known letter and VALUE is appropriate for
  855.    that letter.
  856.  
  857.    For the m88000, the following constants are used:
  858.    `I' requires a non-negative 16-bit value.
  859.    `J' requires a non-positive 16-bit value.
  860.    `K' requires a non-negative value < 32.
  861.    `L' requires a constant with only the upper 16-bits set.
  862.    `M' requires constant values that can be formed with `set'.
  863.    `N' requires a negative value.
  864.    `O' requires zero.
  865.    `P' requires a non-negative value.  */
  866.  
  867. /* Quick tests for certain values.  */
  868. #define SMALL_INT(X) (SMALL_INTVAL (INTVAL (X)))
  869. #define SMALL_INTVAL(I) ((unsigned) (I) < 0x10000)
  870. #define ADD_INT(X) (ADD_INTVAL (INTVAL (X)))
  871. #define ADD_INTVAL(I) ((unsigned) (I) + 0xffff < 0x1ffff)
  872. #define POWER_OF_2(I) ((I) && POWER_OF_2_or_0(I))
  873. #define POWER_OF_2_or_0(I) (((I) & ((unsigned)(I) - 1)) == 0)
  874.  
  875. #define CONST_OK_FOR_LETTER_P(VALUE, C)            \
  876.   ((C) == 'I' ? SMALL_INTVAL (VALUE)            \
  877.    : (C) == 'J' ? SMALL_INTVAL (-(VALUE))        \
  878.    : (C) == 'K' ? (unsigned)(VALUE) < 32        \
  879.    : (C) == 'L' ? ((VALUE) & 0xffff) == 0        \
  880.    : (C) == 'M' ? integer_ok_for_set (VALUE)        \
  881.    : (C) == 'N' ? (VALUE) < 0                \
  882.    : (C) == 'O' ? (VALUE) == 0                \
  883.    : (C) == 'P' ? (VALUE) >= 0                \
  884.    : 0)
  885.  
  886. /* Similar, but for floating constants, and defining letters G and H.
  887.    Here VALUE is the CONST_DOUBLE rtx itself.  For the m88000, the
  888.    constraints are:  `G' requires zero, and `H' requires one or two.  */
  889. #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C)                \
  890.   ((C) == 'G' ? (CONST_DOUBLE_HIGH (VALUE) == 0                \
  891.          && CONST_DOUBLE_LOW (VALUE) == 0)            \
  892.    : 0)
  893.  
  894. /* Letters in the range `Q' through `U' in a register constraint string
  895.    may be defined in a machine-dependent fashion to stand for arbitrary
  896.    operand types.
  897.  
  898.    For the m88k, `Q' handles addresses in a call context.  */
  899.  
  900. #define EXTRA_CONSTRAINT(OP, C)                \
  901.   ((C) == 'Q' ? symbolic_address_p (OP) : 0)
  902.  
  903. /*** Describing Stack Layout ***/
  904.  
  905. /* Define this if pushing a word on the stack moves the stack pointer
  906.    to a smaller address.  */
  907. #define STACK_GROWS_DOWNWARD
  908.  
  909. /* Define this if the addresses of local variable slots are at negative
  910.    offsets from the frame pointer.  */
  911. /* #define FRAME_GROWS_DOWNWARD */
  912.  
  913. /* Offset from the frame pointer to the first local variable slot to be
  914.    allocated. For the m88k, the debugger wants the return address (r1)
  915.    stored at location r30+4, and the previous frame pointer stored at
  916.    location r30.  */
  917. #define STARTING_FRAME_OFFSET 8
  918.  
  919. /* If we generate an insn to push BYTES bytes, this says how many the
  920.    stack pointer really advances by.  The m88k has no push instruction.  */
  921. /*  #define PUSH_ROUNDING(BYTES) */
  922.  
  923. /* If defined, the maximum amount of space required for outgoing arguments
  924.    will be computed and placed into the variable
  925.    `current_function_outgoing_args_size'.  No space will be pushed
  926.    onto the stack for each call; instead, the function prologue should
  927.    increase the stack frame size by this amount.  */
  928. #define ACCUMULATE_OUTGOING_ARGS
  929.  
  930. /* Offset from the stack pointer register to the first location at which
  931.    outgoing arguments are placed.  Use the default value zero.  */
  932. /* #define STACK_POINTER_OFFSET 0 */
  933.  
  934. /* Offset of first parameter from the argument pointer register value.
  935.    Using an argument pointer, this is 0 for the m88k.  GCC knows
  936.    how to eliminate the argument pointer references if necessary.  */
  937. #define FIRST_PARM_OFFSET(FNDECL) 0
  938.  
  939. /* Define this if functions should assume that stack space has been
  940.    allocated for arguments even when their values are passed in
  941.    registers.
  942.  
  943.    The value of this macro is the size, in bytes, of the area reserved for
  944.    arguments passed in registers.
  945.  
  946.    This space can either be allocated by the caller or be a part of the
  947.    machine-dependent stack frame: `OUTGOING_REG_PARM_STACK_SPACE'
  948.    says which.  */
  949. #define REG_PARM_STACK_SPACE(FNDECL) 32
  950.  
  951. /* Define this macro if REG_PARM_STACK_SPACE is defined but stack
  952.    parameters don't skip the area specified by REG_PARM_STACK_SPACE.
  953.    Normally, when a parameter is not passed in registers, it is placed on
  954.    the stack beyond the REG_PARM_STACK_SPACE area.  Defining this macro
  955.    suppresses this behavior and causes the parameter to be passed on the
  956.    stack in its natural location.  */
  957. #define STACK_PARMS_IN_REG_PARM_AREA
  958.  
  959. /* Define this if it is the responsibility of the caller to allocate the
  960.    area reserved for arguments passed in registers.  If
  961.    `ACCUMULATE_OUTGOING_ARGS' is also defined, the only effect of this
  962.    macro is to determine whether the space is included in
  963.    `current_function_outgoing_args_size'.  */
  964. /* #define OUTGOING_REG_PARM_STACK_SPACE */
  965.  
  966. /* Offset from the stack pointer register to an item dynamically allocated
  967.    on the stack, e.g., by `alloca'.
  968.  
  969.    The default value for this macro is `STACK_POINTER_OFFSET' plus the
  970.    length of the outgoing arguments.  The default is correct for most
  971.    machines.  See `function.c' for details.  */
  972. /* #define STACK_DYNAMIC_OFFSET(FUNDECL) ... */
  973.  
  974. /* Value is the number of bytes of arguments automatically
  975.    popped when returning from a subroutine call.
  976.    FUNTYPE is the data type of the function (as a tree),
  977.    or for a library call it is an identifier node for the subroutine name.
  978.    SIZE is the number of bytes of arguments passed on the stack.  */
  979. #define RETURN_POPS_ARGS(FUNTYPE,SIZE) 0
  980.  
  981. /* Define how to find the value returned by a function.
  982.    VALTYPE is the data type of the value (as a tree).
  983.    If the precise function being called is known, FUNC is its FUNCTION_DECL;
  984.    otherwise, FUNC is 0.  */
  985. #define FUNCTION_VALUE(VALTYPE, FUNC) \
  986.   gen_rtx (REG, \
  987.        TYPE_MODE (VALTYPE) == BLKmode ? SImode : TYPE_MODE (VALTYPE), \
  988.        2)
  989.  
  990. /* Define this if it differs from FUNCTION_VALUE.  */
  991. /* #define FUNCTION_OUTGOING_VALUE(VALTYPE, FUNC) ... */
  992.  
  993. /* Disable the promotion of some structures and unions to registers. */
  994. #define RETURN_IN_MEMORY(TYPE) \
  995.   (TYPE_MODE (TYPE) == BLKmode \
  996.    || ((TREE_CODE (TYPE) == RECORD_TYPE || TREE_CODE(TYPE) == UNION_TYPE) \
  997.        && !(TYPE_MODE (TYPE) == SImode \
  998.         || (TYPE_MODE (TYPE) == BLKmode \
  999.         && TYPE_ALIGN (TYPE) == BITS_PER_WORD \
  1000.         && int_size_in_bytes (TYPE) == UNITS_PER_WORD))))
  1001.  
  1002. /* Don't default to pcc-struct-return, because we have already specified
  1003.    exactly how to return structures in the RETURN_IN_MEMORY macro.  */
  1004. #define DEFAULT_PCC_STRUCT_RETURN 0
  1005.  
  1006. /* Define how to find the value returned by a library function
  1007.    assuming the value has mode MODE.  */
  1008. #define LIBCALL_VALUE(MODE)  gen_rtx (REG, MODE, 2)
  1009.  
  1010. /* True if N is a possible register number for a function value
  1011.    as seen by the caller.  */
  1012. #define FUNCTION_VALUE_REGNO_P(N) ((N) == 2)
  1013.  
  1014. /* Determine whether a function argument is passed in a register, and
  1015.    which register.  See m88k.c.  */
  1016. #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
  1017.   m88k_function_arg (CUM, MODE, TYPE, NAMED)
  1018.  
  1019. /* Define this if it differs from FUNCTION_ARG.  */
  1020. /* #define FUNCTION_INCOMING_ARG(CUM, MODE, TYPE, NAMED) ... */
  1021.  
  1022. /* A C expression for the number of words, at the beginning of an
  1023.    argument, must be put in registers.  The value must be zero for
  1024.    arguments that are passed entirely in registers or that are entirely
  1025.    pushed on the stack.  */
  1026. #define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED) (0)
  1027.  
  1028. /* A C expression that indicates when an argument must be passed by
  1029.    reference.  If nonzero for an argument, a copy of that argument is
  1030.    made in memory and a pointer to the argument is passed instead of the
  1031.    argument itself.  The pointer is passed in whatever way is appropriate
  1032.    for passing a pointer to that type.  */
  1033. #define FUNCTION_ARG_PASS_BY_REFERENCE(CUM, MODE, TYPE, NAMED) (0)
  1034.  
  1035. /* A C type for declaring a variable that is used as the first argument
  1036.    of `FUNCTION_ARG' and other related values.  It suffices to count
  1037.    the number of words of argument so far.  */
  1038. #define CUMULATIVE_ARGS int
  1039.  
  1040. /* Initialize a variable CUM of type CUMULATIVE_ARGS for a call to a
  1041.    function whose data type is FNTYPE.  For a library call, FNTYPE is 0. */
  1042. #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME) ((CUM) = 0)
  1043.  
  1044. /* A C statement (sans semicolon) to update the summarizer variable
  1045.    CUM to advance past an argument in the argument list.  The values
  1046.    MODE, TYPE and NAMED describe that argument.  Once this is done,
  1047.    the variable CUM is suitable for analyzing the *following* argument
  1048.    with `FUNCTION_ARG', etc.  (TYPE is null for libcalls where that
  1049.    information may not be available.)  */
  1050. #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)            \
  1051.   do {                                    \
  1052.     enum machine_mode __mode = (TYPE) ? TYPE_MODE (TYPE) : (MODE);    \
  1053.     if ((CUM & 1)                            \
  1054.     && (__mode == DImode || __mode == DFmode            \
  1055.         || ((TYPE) && TYPE_ALIGN (TYPE) > BITS_PER_WORD)))        \
  1056.       CUM++;                                \
  1057.     CUM += (((__mode != BLKmode)                    \
  1058.          ? GET_MODE_SIZE (MODE) : int_size_in_bytes (TYPE))        \
  1059.         + 3) / 4;                            \
  1060.   } while (0)
  1061.  
  1062. /* True if N is a possible register number for function argument passing.
  1063.    On the m88000, these are registers 2 through 9.  */
  1064. #define FUNCTION_ARG_REGNO_P(N) ((N) <= 9 && (N) >= 2)
  1065.  
  1066. /* A C expression which determines whether, and in which direction,
  1067.    to pad out an argument with extra space.  The value should be of
  1068.    type `enum direction': either `upward' to pad above the argument,
  1069.    `downward' to pad below, or `none' to inhibit padding.
  1070.  
  1071.    This macro does not control the *amount* of padding; that is always
  1072.    just enough to reach the next multiple of `FUNCTION_ARG_BOUNDARY'.  */
  1073. #define FUNCTION_ARG_PADDING(MODE, TYPE) \
  1074.   ((MODE) == BLKmode \
  1075.    || ((TYPE) && (TREE_CODE (TYPE) == RECORD_TYPE \
  1076.           || TREE_CODE (TYPE) == UNION_TYPE)) \
  1077.    ? upward : GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY ? downward : none)
  1078.  
  1079. /* If defined, a C expression that gives the alignment boundary, in bits,
  1080.    of an argument with the specified mode and type.  If it is not defined,
  1081.    `PARM_BOUNDARY' is used for all arguments.  */
  1082. #define FUNCTION_ARG_BOUNDARY(MODE, TYPE) \
  1083.   (((TYPE) ? TYPE_ALIGN (TYPE) : GET_MODE_SIZE (MODE)) <= PARM_BOUNDARY \
  1084.     ? PARM_BOUNDARY : 2 * PARM_BOUNDARY)
  1085.  
  1086. /* Generate necessary RTL for __builtin_saveregs().
  1087.    ARGLIST is the argument list; see expr.c.  */
  1088. #define EXPAND_BUILTIN_SAVEREGS(ARGLIST) m88k_builtin_saveregs (ARGLIST)
  1089.  
  1090. /* Generate the assembly code for function entry. */
  1091. #define FUNCTION_PROLOGUE(FILE, SIZE) m88k_begin_prologue(FILE, SIZE)
  1092.  
  1093. /* Perform special actions at the point where the prologue ends.  */
  1094. #define FUNCTION_END_PROLOGUE(FILE) m88k_end_prologue(FILE)
  1095.  
  1096. /* Output assembler code to FILE to increment profiler label # LABELNO
  1097.    for profiling a function entry.  Redefined in sysv3.h, sysv4.h and
  1098.    dgux.h.  */
  1099. #define FUNCTION_PROFILER(FILE, LABELNO) \
  1100.   output_function_profiler (FILE, LABELNO, "mcount", 1)
  1101.  
  1102. /* Maximum length in instructions of the code output by FUNCTION_PROFILER.  */
  1103. #define FUNCTION_PROFILER_LENGTH (5+3+1+5)
  1104.  
  1105. /* Output assembler code to FILE to initialize basic-block profiling for
  1106.    the current module.  LABELNO is unique to each instance.  */
  1107. #define FUNCTION_BLOCK_PROFILER(FILE, LABELNO) \
  1108.   output_function_block_profiler (FILE, LABELNO)
  1109.  
  1110. /* Maximum length in instructions of the code output by
  1111.    FUNCTION_BLOCK_PROFILER.  */
  1112. #define FUNCTION_BLOCK_PROFILER_LENGTH (3+5+2+5)
  1113.  
  1114. /* Output assembler code to FILE to increment the count associated with
  1115.    the basic block number BLOCKNO.  */
  1116. #define BLOCK_PROFILER(FILE, BLOCKNO) output_block_profiler (FILE, BLOCKNO)
  1117.  
  1118. /* Maximum length in instructions of the code output by BLOCK_PROFILER.  */
  1119. #define BLOCK_PROFILER_LENGTH 4
  1120.  
  1121. /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function,
  1122.    the stack pointer does not matter.  The value is tested only in
  1123.    functions that have frame pointers.
  1124.    No definition is equivalent to always zero.  */
  1125. #define EXIT_IGNORE_STACK (1)
  1126.  
  1127. /* Generate the assembly code for function exit. */
  1128. #define FUNCTION_EPILOGUE(FILE, SIZE) m88k_end_epilogue(FILE, SIZE)
  1129.  
  1130. /* Perform special actions at the point where the epilogue begins.  */
  1131. #define FUNCTION_BEGIN_EPILOGUE(FILE) m88k_begin_epilogue(FILE)
  1132.  
  1133. /* Value should be nonzero if functions must have frame pointers.
  1134.    Zero means the frame pointer need not be set up (and parms
  1135.    may be accessed via the stack pointer) in functions that seem suitable.
  1136.    This is computed in `reload', in reload1.c.  */
  1137. #define FRAME_POINTER_REQUIRED \
  1138.   (frame_pointer_needed \
  1139.    || (write_symbols != NO_DEBUG && !TARGET_OCS_FRAME_POSITION))
  1140.  
  1141. /* Definitions for register eliminations.
  1142.  
  1143.    We have two registers that can be eliminated on the m88k.  First, the
  1144.    frame pointer register can often be eliminated in favor of the stack
  1145.    pointer register.  Secondly, the argument pointer register can always be
  1146.    eliminated; it is replaced with either the stack or frame pointer.  */
  1147.  
  1148. /* This is an array of structures.  Each structure initializes one pair
  1149.    of eliminable registers.  The "from" register number is given first,
  1150.    followed by "to".  Eliminations of the same "from" register are listed
  1151.    in order of preference.  */
  1152. #define ELIMINABLE_REGS                \
  1153. {{ ARG_POINTER_REGNUM, STACK_POINTER_REGNUM},    \
  1154.  { ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM},    \
  1155.  { FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}}
  1156.  
  1157. /* Given FROM and TO register numbers, say whether this elimination
  1158.    is allowed.  */
  1159. #define CAN_ELIMINATE(FROM, TO) \
  1160.   (!((FROM) == FRAME_POINTER_REGNUM && FRAME_POINTER_REQUIRED))
  1161.  
  1162. /* Define the offset between two registers, one to be eliminated, and the other
  1163.    its replacement, at the start of a routine.  */
  1164. #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET)             \
  1165. { m88k_layout_frame ();                             \
  1166.   if ((FROM) == FRAME_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM)     \
  1167.       (OFFSET) = m88k_fp_offset;                     \
  1168.   else if ((FROM) == ARG_POINTER_REGNUM && (TO) == FRAME_POINTER_REGNUM) \
  1169.     (OFFSET) = m88k_stack_size - m88k_fp_offset;             \
  1170.   else if ((FROM) == ARG_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM) \
  1171.     (OFFSET) = m88k_stack_size;                         \
  1172.   else                                     \
  1173.     abort ();                                 \
  1174. }
  1175.  
  1176. /*** Trampolines for Nested Functions ***/
  1177.  
  1178. /* Output assembler code for a block containing the constant parts
  1179.    of a trampoline, leaving space for the variable parts.
  1180.  
  1181.    This block is placed on the stack and filled in.  It is aligned
  1182.    0 mod 128 and those portions that are executed are constant.
  1183.    This should work for instruction caches that have cache lines up
  1184.    to the aligned amount (128 is arbitrary), provided no other code
  1185.    producer is attempting to play the same game.  This of course is
  1186.    in violation of any number of 88open standards.  */
  1187.  
  1188. #define TRAMPOLINE_TEMPLATE(FILE)                    \
  1189. {                                    \
  1190.   char buf[256];                            \
  1191.   static int labelno = 0;                        \
  1192.   labelno++;                                \
  1193.   ASM_GENERATE_INTERNAL_LABEL (buf, "LTRMP", labelno);            \
  1194.   /* Save the return address (r1) in the static chain reg (r11).  */    \
  1195.   fprintf (FILE, "\tor\t %s,%s,0\n", reg_names[11], reg_names[1]);    \
  1196.   /* Locate this block; transfer to the next instruction.  */        \
  1197.   fprintf (FILE, "\tbsr\t %s\n", &buf[1]);                    \
  1198.   ASM_OUTPUT_INTERNAL_LABEL (FILE, "LTRMP", labelno);            \
  1199.   /* Save r10; use it as the relative pointer; restore r1.  */        \
  1200.   fprintf (FILE, "\tst\t %s,%s,24\n", reg_names[10], reg_names[1]);    \
  1201.   fprintf (FILE, "\tor\t %s,%s,0\n", reg_names[10], reg_names[1]);    \
  1202.   fprintf (FILE, "\tor\t %s,%s,0\n", reg_names[1], reg_names[11]);    \
  1203.   /* Load the function's address and go there.  */            \
  1204.   fprintf (FILE, "\tld\t %s,%s,32\n", reg_names[11], reg_names[10]);    \
  1205.   fprintf (FILE, "\tjmp.n\t %s\n", reg_names[11]);            \
  1206.   /* Restore r10 and load the static chain register.  */        \
  1207.   fprintf (FILE, "\tld.d\t %s,%s,24\n", reg_names[10], reg_names[10]);    \
  1208.   /* Storage: r10 save area, static chain, function address.  */    \
  1209.   ASM_OUTPUT_INT (FILE, const0_rtx);                    \
  1210.   ASM_OUTPUT_INT (FILE, const0_rtx);                    \
  1211.   ASM_OUTPUT_INT (FILE, const0_rtx);                    \
  1212. }
  1213.  
  1214. /* Length in units of the trampoline for entering a nested function.
  1215.    This is really two components.  The first 32 bytes are fixed and
  1216.    must be copied; the last 12 bytes are just storage that's filled
  1217.    in later.  So for allocation purposes, it's 32+12 bytes, but for
  1218.    initialization purposes, it's 32 bytes.  */
  1219.  
  1220. #define TRAMPOLINE_SIZE (32+12)
  1221.  
  1222. /* Alignment required for a trampoline.  128 is used to find the
  1223.    beginning of a line in the instruction cache and to allow for
  1224.    instruction cache lines of up to 128 bytes.  */
  1225.  
  1226. #define TRAMPOLINE_ALIGNMENT 128
  1227.  
  1228. /* Emit RTL insns to initialize the variable parts of a trampoline.
  1229.    FNADDR is an RTX for the address of the function's pure code.
  1230.    CXT is an RTX for the static chain value for the function.  */
  1231.  
  1232. #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT)            \
  1233. {                                    \
  1234.   emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 40)), FNADDR); \
  1235.   emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 36)), CXT); \
  1236. }
  1237.  
  1238. /*** Library Subroutine Names ***/
  1239.  
  1240. /* Define this macro if GNU CC should generate calls to the System V
  1241.    (and ANSI C) library functions `memcpy' and `memset' rather than
  1242.    the BSD functions `bcopy' and `bzero'.  */
  1243. #define TARGET_MEM_FUNCTIONS
  1244.  
  1245. /*** Addressing Modes ***/
  1246.  
  1247. #define EXTRA_CC_MODES CCEVENmode
  1248.  
  1249. #define EXTRA_CC_NAMES "CCEVEN"
  1250.  
  1251. #define SELECT_CC_MODE(OP,X,Y) CCmode
  1252.  
  1253. /* #define HAVE_POST_INCREMENT */
  1254. /* #define HAVE_POST_DECREMENT */
  1255.  
  1256. /* #define HAVE_PRE_DECREMENT */
  1257. /* #define HAVE_PRE_INCREMENT */
  1258.  
  1259. /* Recognize any constant value that is a valid address.
  1260.    When PIC, we do not accept an address that would require a scratch reg
  1261.    to load into a register.  */
  1262.  
  1263. #define CONSTANT_ADDRESS_P(X)   \
  1264.   (GET_CODE (X) == LABEL_REF || GET_CODE (X) == SYMBOL_REF        \
  1265.    || GET_CODE (X) == CONST_INT || GET_CODE (X) == HIGH                 \
  1266.    || (GET_CODE (X) == CONST                                            \
  1267.        && ! (flag_pic && pic_address_needs_scratch (X))))
  1268.  
  1269.  
  1270. /* Maximum number of registers that can appear in a valid memory address.  */
  1271. #define MAX_REGS_PER_ADDRESS 2
  1272.  
  1273. /* The condition for memory shift insns.  */
  1274. #define SCALED_ADDRESS_P(ADDR)            \
  1275.   (GET_CODE (ADDR) == PLUS            \
  1276.    && (GET_CODE (XEXP (ADDR, 0)) == MULT    \
  1277.        || GET_CODE (XEXP (ADDR, 1)) == MULT))
  1278.  
  1279. /* Can the reference to X be made short?  */
  1280. #define SHORT_ADDRESS_P(X,TEMP) \
  1281.   ((TEMP) = (GET_CODE (X) == CONST ? get_related_value (X) : X), \
  1282.    ((TEMP) && GET_CODE (TEMP) == SYMBOL_REF && SYMBOL_REF_FLAG (TEMP)))
  1283.  
  1284. /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
  1285.    that is a valid memory address for an instruction.
  1286.    The MODE argument is the machine mode for the MEM expression
  1287.    that wants to use this address.
  1288.  
  1289.    On the m88000, a legitimate address has the form REG, REG+REG,
  1290.    REG+SMALLINT, REG+(REG*modesize) (REG[REG]), or SMALLINT.
  1291.  
  1292.    The register elimination process should deal with the argument
  1293.    pointer and frame pointer changing to REG+SMALLINT.  */
  1294.  
  1295. #define LEGITIMATE_INDEX_P(X, MODE)            \
  1296.    ((GET_CODE (X) == CONST_INT                \
  1297.      && SMALL_INT (X))                    \
  1298.     || (REG_P (X)                    \
  1299.     && REG_OK_FOR_INDEX_P (X))            \
  1300.     || (GET_CODE (X) == MULT                \
  1301.     && REG_P (XEXP (X, 0))                \
  1302.     && REG_OK_FOR_INDEX_P (XEXP (X, 0))        \
  1303.     && GET_CODE (XEXP (X, 1)) == CONST_INT        \
  1304.     && INTVAL (XEXP (X, 1)) == GET_MODE_SIZE (MODE)))
  1305.  
  1306. #define RTX_OK_FOR_BASE_P(X)                        \
  1307.   ((GET_CODE (X) == REG && REG_OK_FOR_BASE_P (X))            \
  1308.   || (GET_CODE (X) == SUBREG                        \
  1309.       && GET_CODE (SUBREG_REG (X)) == REG                \
  1310.       && REG_OK_FOR_BASE_P (SUBREG_REG (X))))
  1311.  
  1312. #define RTX_OK_FOR_INDEX_P(X)                        \
  1313.   ((GET_CODE (X) == REG && REG_OK_FOR_INDEX_P (X))            \
  1314.   || (GET_CODE (X) == SUBREG                        \
  1315.       && GET_CODE (SUBREG_REG (X)) == REG                \
  1316.       && REG_OK_FOR_INDEX_P (SUBREG_REG (X))))
  1317.  
  1318. #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR)        \
  1319. {                            \
  1320.   register rtx _x;                    \
  1321.   if (REG_P (X))                    \
  1322.     {                            \
  1323.       if (REG_OK_FOR_BASE_P (X))            \
  1324.     goto ADDR;                    \
  1325.     }                            \
  1326.   else if (GET_CODE (X) == PLUS)            \
  1327.     {                            \
  1328.       register rtx _x0 = XEXP (X, 0);            \
  1329.       register rtx _x1 = XEXP (X, 1);            \
  1330.       if ((flag_pic                    \
  1331.        && _x0 == pic_offset_table_rtx        \
  1332.        && (flag_pic == 2                \
  1333.            ? RTX_OK_FOR_BASE_P (_x1)        \
  1334.            : (GET_CODE (_x1) == SYMBOL_REF        \
  1335.           || GET_CODE (_x1) == LABEL_REF)))    \
  1336.       || (REG_P (_x0)                \
  1337.           && (REG_OK_FOR_BASE_P (_x0)        \
  1338.           && LEGITIMATE_INDEX_P (_x1, MODE)))    \
  1339.       || (REG_P (_x1)                \
  1340.           && (REG_OK_FOR_BASE_P (_x1)        \
  1341.           && LEGITIMATE_INDEX_P (_x0, MODE))))    \
  1342.     goto ADDR;                    \
  1343.     }                            \
  1344.   else if (GET_CODE (X) == LO_SUM)            \
  1345.     {                            \
  1346.       register rtx _x0 = XEXP (X, 0);            \
  1347.       register rtx _x1 = XEXP (X, 1);            \
  1348.       if (((REG_P (_x0)                    \
  1349.         && REG_OK_FOR_BASE_P (_x0))            \
  1350.        || (GET_CODE (_x0) == SUBREG            \
  1351.            && REG_P (SUBREG_REG (_x0))        \
  1352.            && REG_OK_FOR_BASE_P (SUBREG_REG (_x0)))) \
  1353.       && CONSTANT_P (_x1))                \
  1354.     goto ADDR;                    \
  1355.     }                            \
  1356.   else if (GET_CODE (X) == CONST_INT            \
  1357.        && SMALL_INT (X))                \
  1358.     goto ADDR;                        \
  1359.   else if (SHORT_ADDRESS_P (X, _x))            \
  1360.     goto ADDR;                        \
  1361. }
  1362.  
  1363. /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx
  1364.    and check its validity for a certain class.
  1365.    We have two alternate definitions for each of them.
  1366.    The usual definition accepts all pseudo regs; the other rejects
  1367.    them unless they have been allocated suitable hard regs.
  1368.    The symbol REG_OK_STRICT causes the latter definition to be used.
  1369.  
  1370.    Most source files want to accept pseudo regs in the hope that
  1371.    they will get allocated to the class that the insn wants them to be in.
  1372.    Source files for reload pass need to be strict.
  1373.    After reload, it makes no difference, since pseudo regs have
  1374.    been eliminated by then.  */
  1375.  
  1376. #ifndef REG_OK_STRICT
  1377.  
  1378. /* Nonzero if X is a hard reg that can be used as an index
  1379.    or if it is a pseudo reg.  Not the argument pointer.  */
  1380. #define REG_OK_FOR_INDEX_P(X)                                         \
  1381.   (!XRF_REGNO_P(REGNO (X)))
  1382. /* Nonzero if X is a hard reg that can be used as a base reg
  1383.    or if it is a pseudo reg.  */
  1384. #define REG_OK_FOR_BASE_P(X) (REG_OK_FOR_INDEX_P (X))
  1385.  
  1386. #else
  1387.  
  1388. /* Nonzero if X is a hard reg that can be used as an index.  */
  1389. #define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X))
  1390. /* Nonzero if X is a hard reg that can be used as a base reg.  */
  1391. #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X))
  1392.  
  1393. #endif
  1394.  
  1395. /* Try machine-dependent ways of modifying an illegitimate address
  1396.    to be legitimate.  If we find one, return the new, valid address.
  1397.    This macro is used in only one place: `memory_address' in explow.c.
  1398.  
  1399.    OLDX is the address as it was before break_out_memory_refs was called.
  1400.    In some cases it is useful to look at this to decide what needs to be done.
  1401.  
  1402.    MODE and WIN are passed so that this macro can use
  1403.    GO_IF_LEGITIMATE_ADDRESS.
  1404.  
  1405.    It is always safe for this macro to do nothing.  It exists to recognize
  1406.    opportunities to optimize the output.  */
  1407.  
  1408. /* On the m88000, change REG+N into REG+REG, and REG+(X*Y) into REG+REG.  */
  1409.  
  1410. #define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN)            \
  1411. {                                \
  1412.   if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 1)))    \
  1413.     (X) = gen_rtx (PLUS, SImode, XEXP (X, 0),            \
  1414.            copy_to_mode_reg (SImode, XEXP (X, 1)));    \
  1415.   if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 0)))    \
  1416.     (X) = gen_rtx (PLUS, SImode, XEXP (X, 1),            \
  1417.            copy_to_mode_reg (SImode, XEXP (X, 0)));    \
  1418.   if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == MULT)    \
  1419.     (X) = gen_rtx (PLUS, SImode, XEXP (X, 1),            \
  1420.            force_operand (XEXP (X, 0), 0));        \
  1421.   if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == MULT)    \
  1422.     (X) = gen_rtx (PLUS, SImode, XEXP (X, 0),            \
  1423.            force_operand (XEXP (X, 1), 0));        \
  1424.   if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == PLUS)    \
  1425.     (X) = gen_rtx (PLUS, Pmode, force_operand (XEXP (X, 0), NULL_RTX),\
  1426.            XEXP (X, 1));                \
  1427.   if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == PLUS)    \
  1428.     (X) = gen_rtx (PLUS, Pmode, XEXP (X, 0),            \
  1429.            force_operand (XEXP (X, 1), NULL_RTX));    \
  1430.   if (GET_CODE (X) == SYMBOL_REF || GET_CODE (X) == CONST    \
  1431.        || GET_CODE (X) == LABEL_REF)            \
  1432.     (X) = legitimize_address (flag_pic, X, 0, 0);        \
  1433.   if (memory_address_p (MODE, X))                \
  1434.     goto WIN; }
  1435.  
  1436. /* Go to LABEL if ADDR (a legitimate address expression)
  1437.    has an effect that depends on the machine mode it is used for.
  1438.    On the the m88000 this is never true.  */
  1439.  
  1440. #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL)
  1441.  
  1442. /* Nonzero if the constant value X is a legitimate general operand.
  1443.    It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */
  1444. #define LEGITIMATE_CONSTANT_P(X) (1)
  1445.  
  1446. /* Define this, so that when PIC, reload won't try to reload invalid
  1447.    addresses which require two reload registers.  */
  1448.  
  1449. #define LEGITIMATE_PIC_OPERAND_P(X)  (! pic_address_needs_scratch (X))
  1450.  
  1451.  
  1452. /*** Condition Code Information ***/
  1453.  
  1454. /* C code for a data type which is used for declaring the `mdep'
  1455.    component of `cc_status'.  It defaults to `int'.  */
  1456. /* #define CC_STATUS_MDEP int */
  1457.  
  1458. /* A C expression to initialize the `mdep' field to "empty".  */
  1459. /* #define CC_STATUS_MDEP_INIT (cc_status.mdep = 0) */
  1460.  
  1461. /* Macro to zap the normal portions of CC_STATUS, but leave the
  1462.    machine dependent parts (ie, literal synthesis) alone.  */
  1463. /* #define CC_STATUS_INIT_NO_MDEP \
  1464.   (cc_status.flags = 0, cc_status.value1 = 0, cc_status.value2 = 0) */
  1465.  
  1466. /* When using a register to hold the condition codes, the cc_status
  1467.    mechanism cannot be used.  */
  1468. #define NOTICE_UPDATE_CC(EXP, INSN) (0)
  1469.  
  1470. /*** Miscellaneous Parameters ***/
  1471.  
  1472. /* Define the codes that are matched by predicates in m88k.c.  */
  1473. #define PREDICATE_CODES                              \
  1474.   {"move_operand", {SUBREG, REG, CONST_INT, LO_SUM, MEM}},        \
  1475.   {"call_address_operand", {SUBREG, REG, SYMBOL_REF, LABEL_REF, CONST}}, \
  1476.   {"arith_operand", {SUBREG, REG, CONST_INT}},                \
  1477.   {"arith5_operand", {SUBREG, REG, CONST_INT}},                \
  1478.   {"arith32_operand", {SUBREG, REG, CONST_INT}},            \
  1479.   {"arith64_operand", {SUBREG, REG, CONST_INT}},            \
  1480.   {"int5_operand", {CONST_INT}},                    \
  1481.   {"int32_operand", {CONST_INT}},                    \
  1482.   {"add_operand", {SUBREG, REG, CONST_INT}},                \
  1483.   {"reg_or_bbx_mask_operand", {SUBREG, REG, CONST_INT}},        \
  1484.   {"real_or_0_operand", {SUBREG, REG, CONST_DOUBLE}},            \
  1485.   {"reg_or_0_operand", {SUBREG, REG, CONST_INT}},                       \
  1486.   {"relop", {EQ, NE, LT, LE, GE, GT, LTU, LEU, GEU, GTU}},        \
  1487.   {"even_relop", {EQ, LT, GT, LTU, GTU}},        \
  1488.   {"odd_relop", { NE, LE, GE, LEU, GEU}},        \
  1489.   {"partial_ccmode_register_operand", { SUBREG, REG}},            \
  1490.   {"relop_no_unsigned", {EQ, NE, LT, LE, GE, GT}},            \
  1491.   {"equality_op", {EQ, NE}},                        \
  1492.   {"pc_or_label_ref", {PC, LABEL_REF}},
  1493.  
  1494. /* The case table contains either words or branch instructions.  This says
  1495.    which.  We always claim that the vector is PC-relative.  It is position
  1496.    independent when -fpic is used.  */
  1497. #define CASE_VECTOR_INSNS (TARGET_88100 || flag_pic)
  1498.  
  1499. /* An alias for a machine mode name.  This is the machine mode that
  1500.    elements of a jump-table should have.  */
  1501. #define CASE_VECTOR_MODE SImode
  1502.  
  1503. /* Define this macro if jump-tables should contain relative addresses.  */
  1504. #define CASE_VECTOR_PC_RELATIVE
  1505.  
  1506. /* Define this if control falls through a `case' insn when the index
  1507.    value is out of range.  This means the specified default-label is
  1508.    actually ignored by the `case' insn proper.  */
  1509. /* #define CASE_DROPS_THROUGH */
  1510.  
  1511. /* Define this to be the smallest number of different values for which it
  1512.    is best to use a jump-table instead of a tree of conditional branches.
  1513.    The default is 4 for machines with a casesi instruction and 5 otherwise.
  1514.    The best 88110 number is around 7, though the exact number isn't yet
  1515.    known.  A third alternative for the 88110 is to use a binary tree of
  1516.    bb1 instructions on bits 2/1/0 if the range is dense.  This may not
  1517.    win very much though.  */
  1518. #define CASE_VALUES_THRESHOLD (TARGET_88100 ? 4 : 7)
  1519.  
  1520. /* Specify the tree operation to be used to convert reals to integers.  */
  1521. #define IMPLICIT_FIX_EXPR FIX_ROUND_EXPR
  1522.  
  1523. /* This is the kind of divide that is easiest to do in the general case.  */
  1524. #define EASY_DIV_EXPR TRUNC_DIV_EXPR
  1525.  
  1526. /* Define this as 1 if `char' should by default be signed; else as 0.  */
  1527. #define DEFAULT_SIGNED_CHAR 1
  1528.  
  1529. /* The 88open ABI says size_t is unsigned int.  */
  1530. #define SIZE_TYPE "unsigned int"
  1531.  
  1532. /* Allow and ignore #sccs directives */
  1533. #define SCCS_DIRECTIVE
  1534.  
  1535. /* Handle #pragma pack and sometimes #pragma weak.  */
  1536. #define HANDLE_SYSV_PRAGMA
  1537.  
  1538. /* Tell when to handle #pragma weak.  This is only done for V.4.  */
  1539. #define HANDLE_PRAGMA_WEAK TARGET_SVR4
  1540.  
  1541. /* Max number of bytes we can move from memory to memory
  1542.    in one reasonably fast instruction.  */
  1543. #define MOVE_MAX 8
  1544.  
  1545. /* Define if normal loads of shorter-than-word items from memory clears
  1546.    the rest of the bigs in the register.  */
  1547. #define BYTE_LOADS_ZERO_EXTEND
  1548.  
  1549. /* Zero if access to memory by bytes is faster.  */
  1550. #define SLOW_BYTE_ACCESS 1
  1551.  
  1552. /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits
  1553.    is done just by pretending it is already truncated.  */
  1554. #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1
  1555.  
  1556. /* Define this if addresses of constant functions
  1557.    shouldn't be put through pseudo regs where they can be cse'd.
  1558.    Desirable on machines where ordinary constants are expensive
  1559.    but a CALL with constant address is cheap.  */
  1560. #define NO_FUNCTION_CSE
  1561.  
  1562. /* Define this macro if an argument declared as `char' or
  1563.    `short' in a prototype should actually be passed as an
  1564.    `int'.  In addition to avoiding errors in certain cases of
  1565.    mismatch, it also makes for better code on certain machines.  */
  1566. #define PROMOTE_PROTOTYPES
  1567.  
  1568. /* Define this macro if a float function always returns float
  1569.    (even in traditional mode).  Redefined in luna.h.  */
  1570. #define TRADITIONAL_RETURN_FLOAT
  1571.  
  1572. /* We assume that the store-condition-codes instructions store 0 for false
  1573.    and some other value for true.  This is the value stored for true.  */
  1574. #define STORE_FLAG_VALUE -1
  1575.  
  1576. /* Specify the machine mode that pointers have.
  1577.    After generation of rtl, the compiler makes no further distinction
  1578.    between pointers and any other objects of this machine mode.  */
  1579. #define Pmode SImode
  1580.  
  1581. /* A function address in a call instruction
  1582.    is a word address (for indexing purposes)
  1583.    so give the MEM rtx word mode.  */
  1584. #define FUNCTION_MODE SImode
  1585.  
  1586. /* A barrier will be aligned so account for the possible expansion.
  1587.    A volatile load may be preceded by a serializing instruction.
  1588.    Account for profiling code output at NOTE_INSN_PROLOGUE_END.
  1589.    Account for block profiling code at basic block boundaries.  */
  1590. #define ADJUST_INSN_LENGTH(RTX, LENGTH)                    \
  1591.   if (GET_CODE (RTX) == BARRIER                        \
  1592.       || (TARGET_SERIALIZE_VOLATILE                    \
  1593.       && GET_CODE (RTX) == INSN                    \
  1594.       && GET_CODE (PATTERN (RTX)) == SET                \
  1595.       && ((GET_CODE (SET_SRC (PATTERN (RTX))) == MEM        \
  1596.            && MEM_VOLATILE_P (SET_SRC (PATTERN (RTX)))))))        \
  1597.     LENGTH += 1;                            \
  1598.   else if (GET_CODE (RTX) == NOTE                    \
  1599.        && NOTE_LINE_NUMBER (RTX) == NOTE_INSN_PROLOGUE_END)        \
  1600.     {                                    \
  1601.       if (profile_block_flag)                        \
  1602.     LENGTH += FUNCTION_BLOCK_PROFILER_LENGTH;            \
  1603.       if (profile_flag)                            \
  1604.     LENGTH += (FUNCTION_PROFILER_LENGTH + REG_PUSH_LENGTH        \
  1605.            + REG_POP_LENGTH);                    \
  1606.     }                                    \
  1607.   else if (profile_block_flag                        \
  1608.        && (GET_CODE (RTX) == CODE_LABEL                \
  1609.            || GET_CODE (RTX) == JUMP_INSN                \
  1610.            || (GET_CODE (RTX) == INSN                \
  1611.            && GET_CODE (PATTERN (RTX)) == SEQUENCE        \
  1612.            && GET_CODE (XVECEXP (PATTERN (RTX), 0, 0)) == JUMP_INSN)))\
  1613.     LENGTH += BLOCK_PROFILER_LENGTH;
  1614.  
  1615. /* Track the state of the last volatile memory reference.  Clear the
  1616.    state with CC_STATUS_INIT for now.  */
  1617. #define CC_STATUS_INIT m88k_volatile_code = '\0'
  1618.  
  1619. /* Compute the cost of computing a constant rtl expression RTX
  1620.    whose rtx-code is CODE.  The body of this macro is a portion
  1621.    of a switch statement.  If the code is computed here,
  1622.    return it with a return statement.  Otherwise, break from the switch.
  1623.  
  1624.    We assume that any 16 bit integer can easily be recreated, so we
  1625.    indicate 0 cost, in an attempt to get GCC not to optimize things
  1626.    like comparison against a constant.
  1627.  
  1628.    The cost of CONST_DOUBLE is zero (if it can be placed in an insn, it
  1629.    is as good as a register; since it can't be placed in any insn, it
  1630.    won't do anything in cse, but it will cause expand_binop to pass the
  1631.    constant to the define_expands).  */
  1632. #define CONST_COSTS(RTX,CODE,OUTER_CODE)        \
  1633.   case CONST_INT:                    \
  1634.     if (SMALL_INT (RTX))                \
  1635.       return 0;                        \
  1636.     else if (SMALL_INTVAL (- INTVAL (RTX)))        \
  1637.       return 2;                        \
  1638.     else if (classify_integer (SImode, INTVAL (RTX)) != m88k_oru_or) \
  1639.       return 4;                        \
  1640.     return 7;                        \
  1641.   case HIGH:                        \
  1642.     return 2;                        \
  1643.   case CONST:                        \
  1644.   case LABEL_REF:                    \
  1645.   case SYMBOL_REF:                    \
  1646.     if (flag_pic)                    \
  1647.       return (flag_pic == 2) ? 11 : 8;            \
  1648.     return 5;                        \
  1649.   case CONST_DOUBLE:                    \
  1650.     return 0;
  1651.  
  1652. /* Provide the costs of an addressing mode that contains ADDR.
  1653.    If ADDR is not a valid address, its cost is irrelevant.
  1654.    REG+REG is made slightly more expensive because it might keep
  1655.    a register live for longer than we might like.  */
  1656. #define ADDRESS_COST(ADDR)                \
  1657.   (GET_CODE (ADDR) == REG ? 1 :                \
  1658.    GET_CODE (ADDR) == LO_SUM ? 1 :            \
  1659.    GET_CODE (ADDR) == HIGH ? 2 :            \
  1660.    GET_CODE (ADDR) == MULT ? 1 :            \
  1661.    GET_CODE (ADDR) != PLUS ? 4 :            \
  1662.    (REG_P (XEXP (ADDR, 0)) && REG_P (XEXP (ADDR, 1))) ? 2 : 1)
  1663.  
  1664. /* Provide the costs of a rtl expression.  This is in the body of a
  1665.    switch on CODE.  */
  1666. #define RTX_COSTS(X,CODE,OUTER_CODE)                \
  1667.   case MEM:                        \
  1668.     return COSTS_N_INSNS (2);                \
  1669.   case MULT:                        \
  1670.     return COSTS_N_INSNS (3);                \
  1671.   case DIV:                        \
  1672.   case UDIV:                        \
  1673.   case MOD:                        \
  1674.   case UMOD:                        \
  1675.     return COSTS_N_INSNS (38);
  1676.  
  1677. /* A C expressions returning the cost of moving data of MODE from a register
  1678.    to or from memory.  This is more costly than between registers.  */
  1679. #define MEMORY_MOVE_COST(MODE) 4
  1680.  
  1681. /* Provide the cost of a branch.  Exact meaning under development.  */
  1682. #define BRANCH_COST (TARGET_88100 ? 1 : 2)
  1683.  
  1684. /* A C statement (sans semicolon) to update the integer variable COST
  1685.    based on the relationship between INSN that is dependent on
  1686.    DEP_INSN through the dependence LINK.  The default is to make no
  1687.    adjustment to COST.  On the m88k, ignore the cost of anti- and
  1688.    output-dependencies.  On the m88100, a store can issue two cycles
  1689.    before the value (not the address) has finished computing.  */
  1690. #define ADJUST_COST(INSN,LINK,DEP_INSN,COST)                \
  1691.   do {                                    \
  1692.     if (REG_NOTE_KIND (LINK) != 0)                    \
  1693.       (COST) = 0; /* Anti or output dependence.  */            \
  1694.     else if (! TARGET_88100                        \
  1695.          && recog_memoized (INSN) >= 0                \
  1696.          && get_attr_type (INSN) == TYPE_STORE            \
  1697.          && SET_SRC (PATTERN (INSN)) == SET_DEST (PATTERN (DEP_INSN))) \
  1698.       (COST) -= 4; /* 88110 store reservation station.  */        \
  1699.   } while (0)
  1700.  
  1701. /* Define this to be nonzero if the character `$' should be allowed
  1702.    by default in identifier names.  */
  1703. #define    DOLLARS_IN_IDENTIFIERS    1
  1704.  
  1705. /* Do not break .stabs pseudos into continuations.  */
  1706. #define DBX_CONTIN_LENGTH 0
  1707.  
  1708. /*** Output of Assembler Code ***/
  1709.  
  1710. /* Control the assembler format that we output.  */
  1711.  
  1712. /* Allow pseudo-ops to be overridden.  Override these in svr[34].h.  */
  1713. #undef    INT_ASM_OP
  1714. #undef    ASCII_DATA_ASM_OP
  1715. #undef    CONST_SECTION_ASM_OP
  1716. #undef    CTORS_SECTION_ASM_OP
  1717. #undef    DTORS_SECTION_ASM_OP
  1718. #undef    INIT_SECTION_ASM_OP
  1719. #undef    FINI_SECTION_ASM_OP
  1720. #undef    TYPE_ASM_OP
  1721. #undef    SIZE_ASM_OP
  1722. #undef    WEAK_ASM_OP
  1723. #undef    SET_ASM_OP
  1724. #undef    SKIP_ASM_OP
  1725. #undef    COMMON_ASM_OP
  1726. #undef    ALIGN_ASM_OP
  1727. #undef    IDENT_ASM_OP
  1728.  
  1729. /* These are used in varasm.c as well.  */
  1730. #define TEXT_SECTION_ASM_OP    "text"
  1731. #define DATA_SECTION_ASM_OP    "data"
  1732.  
  1733. /* Other sections.  */
  1734. #define CONST_SECTION_ASM_OP (TARGET_SVR4            \
  1735.                   ? "section\t .rodata,\"a\""    \
  1736.                   : "section\t .rodata,\"x\"")
  1737. #define TDESC_SECTION_ASM_OP (TARGET_SVR4            \
  1738.                   ? "section\t .tdesc,\"a\""    \
  1739.                   : "section\t .tdesc,\"x\"")
  1740.  
  1741. /* These must be constant strings for crtstuff.c.  */
  1742. #define CTORS_SECTION_ASM_OP    "section\t .ctors,\"d\""
  1743. #define DTORS_SECTION_ASM_OP    "section\t .dtors,\"d\""
  1744. #define INIT_SECTION_ASM_OP    "section\t .init,\"x\""
  1745. #define FINI_SECTION_ASM_OP    "section\t .fini,\"x\""
  1746.  
  1747. /* These are pretty much common to all assemblers.  */
  1748. #define IDENT_ASM_OP        "ident"
  1749. #define FILE_ASM_OP        "file"
  1750. #define SECTION_ASM_OP        "section"
  1751. #define SET_ASM_OP        "def"
  1752. #define GLOBAL_ASM_OP        "global"
  1753. #define ALIGN_ASM_OP        "align"
  1754. #define SKIP_ASM_OP        "zero"
  1755. #define COMMON_ASM_OP        "comm"
  1756. #define BSS_ASM_OP        "bss"
  1757. #define FLOAT_ASM_OP        "float"
  1758. #define DOUBLE_ASM_OP        "double"
  1759. #define INT_ASM_OP        "word"
  1760. #define ASM_LONG        INT_ASM_OP
  1761. #define SHORT_ASM_OP        "half"
  1762. #define CHAR_ASM_OP        "byte"
  1763. #define ASCII_DATA_ASM_OP    "string"
  1764.  
  1765. /* These are particular to the global pool optimization.  */
  1766. #define SBSS_ASM_OP        "sbss"
  1767. #define SCOMM_ASM_OP        "scomm"
  1768. #define SDATA_SECTION_ASM_OP    "sdata"
  1769.  
  1770. /* These are specific to PIC.  */
  1771. #define TYPE_ASM_OP        "type"
  1772. #define SIZE_ASM_OP        "size"
  1773. #define WEAK_ASM_OP        "weak"
  1774. #ifndef AS_BUG_POUND_TYPE /* Faulty assemblers require @ rather than #.  */
  1775. #undef    TYPE_OPERAND_FMT
  1776. #define TYPE_OPERAND_FMT    "#%s"
  1777. #endif
  1778.  
  1779. /* These are specific to version 03.00 assembler syntax.  */
  1780. #define INTERNAL_ASM_OP        "local"
  1781. #define VERSION_ASM_OP        "version"
  1782. #define UNALIGNED_SHORT_ASM_OP    "uahalf"
  1783. #define UNALIGNED_INT_ASM_OP    "uaword"
  1784. #define PUSHSECTION_ASM_OP    "section"
  1785. #define POPSECTION_ASM_OP    "previous"
  1786.  
  1787. /* These are specific to the version 04.00 assembler syntax.  */
  1788. #define REQUIRES_88110_ASM_OP    "requires_88110"
  1789.  
  1790. /* Output any initial stuff to the assembly file.  Always put out
  1791.    a file directive, even if not debugging.
  1792.  
  1793.    Immediately after putting out the file, put out a "sem.<value>"
  1794.    declaration.  This should be harmless on other systems, and
  1795.    is used in DG/UX by the debuggers to supplement COFF.  The
  1796.    fields in the integer value are as follows:
  1797.  
  1798.    Bits    Value    Meaning
  1799.    ----    -----    -------
  1800.    0-1    0    No information about stack locations
  1801.     1    Auto/param locations are based on r30
  1802.     2    Auto/param locations are based on CFA
  1803.  
  1804.    3-2    0    No information on dimension order
  1805.     1    Array dims in sym table matches source language
  1806.     2    Array dims in sym table is in reverse order
  1807.  
  1808.    5-4    0    No information about the case of global names
  1809.     1    Global names appear in the symbol table as in the source
  1810.     2    Global names have been converted to lower case
  1811.     3    Global names have been converted to upper case.  */
  1812.  
  1813. #ifdef SDB_DEBUGGING_INFO
  1814. #define ASM_COFFSEM(FILE)                        \
  1815.     if (write_symbols == SDB_DEBUG)                    \
  1816.       {                                    \
  1817.     fprintf (FILE, "\nsem.%x:\t\t; %s\n",                \
  1818.          (((TARGET_OCS_FRAME_POSITION) ? 2 : 1) << 0) + (1 << 2) + (1 << 4),\
  1819.          (TARGET_OCS_FRAME_POSITION)                \
  1820.             ? "frame is CFA, normal array dims, case unchanged" \
  1821.             : "frame is r30, normal array dims, case unchanged"); \
  1822.       }
  1823. #else
  1824. #define ASM_COFFSEM(FILE)
  1825. #endif
  1826.  
  1827. /* Output the first line of the assembly file.  Redefined in dgux.h.  */
  1828.  
  1829. #define ASM_FIRST_LINE(FILE)                        \
  1830.   do {                                    \
  1831.     if (TARGET_SVR4)                            \
  1832.       {                                    \
  1833.     if (TARGET_88110)                        \
  1834.       fprintf (FILE, "\t%s\t \"%s\"\n", VERSION_ASM_OP, "04.00");   \
  1835.     else                                \
  1836.       fprintf (FILE, "\t%s\t \"%s\"\n", VERSION_ASM_OP, "03.00");   \
  1837.       }                                    \
  1838.   } while (0)
  1839.  
  1840. /* Override svr[34].h.  */
  1841. #undef    ASM_FILE_START
  1842. #define ASM_FILE_START(FILE) \
  1843.   output_file_start (FILE, f_options, sizeof f_options / sizeof f_options[0], \
  1844.              W_options, sizeof W_options / sizeof W_options[0])
  1845.  
  1846. #undef    ASM_FILE_END
  1847.  
  1848. #define ASM_OUTPUT_SOURCE_FILENAME(FILE, NAME) \
  1849.   fprintf (FILE, "\t%s\t \"%s\"\n", FILE_ASM_OP, NAME)
  1850.  
  1851. #ifdef SDB_DEBUGGING_INFO
  1852. #undef ASM_OUTPUT_SOURCE_LINE
  1853. #define ASM_OUTPUT_SOURCE_LINE(FILE, LINE)            \
  1854.   if (m88k_prologue_done)                    \
  1855.     fprintf (FILE, "\n\tln\t %d\t\t\t\t; Real source line %d\n",\
  1856.          LINE - sdb_begin_function_line, LINE)
  1857. #endif
  1858.  
  1859. /* Code to handle #ident directives.  Override svr[34].h definition.  */
  1860. #undef    ASM_OUTPUT_IDENT
  1861. #ifdef DBX_DEBUGGING_INFO
  1862. #define ASM_OUTPUT_IDENT(FILE, NAME)
  1863. #else
  1864. #define ASM_OUTPUT_IDENT(FILE, NAME) \
  1865.   output_ascii (FILE, IDENT_ASM_OP, 4000, NAME, strlen (NAME));
  1866. #endif
  1867.  
  1868. /* Output to assembler file text saying following lines
  1869.    may contain character constants, extra white space, comments, etc.  */
  1870. #define ASM_APP_ON ""
  1871.  
  1872. /* Output to assembler file text saying following lines
  1873.    no longer contain unusual constructs.  */
  1874. #define ASM_APP_OFF ""
  1875.  
  1876. /* Format the assembly opcode so that the arguments are all aligned.
  1877.    The maximum instruction size is 8 characters (fxxx.xxx), so a tab and a
  1878.    space will do to align the output.  Abandon the output if a `%' is
  1879.    encountered.  */
  1880. #define ASM_OUTPUT_OPCODE(STREAM, PTR)                    \
  1881.   {                                    \
  1882.     int ch;                                \
  1883.     char *orig_ptr;                            \
  1884.                                     \
  1885.     for (orig_ptr = (PTR);                        \
  1886.      (ch = *(PTR)) && ch != ' ' && ch != '\t' && ch != '\n' && ch != '%'; \
  1887.      (PTR)++)                            \
  1888.       putc (ch, STREAM);                        \
  1889.                                     \
  1890.     if (ch == ' ' && orig_ptr != (PTR) && (PTR) - orig_ptr < 8)        \
  1891.       putc ('\t', STREAM);                        \
  1892.   }
  1893.  
  1894. /* How to refer to registers in assembler output.
  1895.    This sequence is indexed by compiler's hard-register-number.
  1896.    Updated by OVERRIDE_OPTIONS to include the # for version 03.00 syntax.  */
  1897.  
  1898. #define REGISTER_NAMES \
  1899.   {"#r0"+1, "#r1"+1, "#r2"+1, "#r3"+1, "#r4"+1, "#r5"+1, "#r6"+1, "#r7"+1, \
  1900.    "#r8"+1, "#r9"+1, "#r10"+1,"#r11"+1,"#r12"+1,"#r13"+1,"#r14"+1,"#r15"+1,\
  1901.    "#r16"+1,"#r17"+1,"#r18"+1,"#r19"+1,"#r20"+1,"#r21"+1,"#r22"+1,"#r23"+1,\
  1902.    "#r24"+1,"#r25"+1,"#r26"+1,"#r27"+1,"#r28"+1,"#r29"+1,"#r30"+1,"#r31"+1,\
  1903.    "#x0"+1, "#x1"+1, "#x2"+1, "#x3"+1, "#x4"+1, "#x5"+1, "#x6"+1, "#x7"+1, \
  1904.    "#x8"+1, "#x9"+1, "#x10"+1,"#x11"+1,"#x12"+1,"#x13"+1,"#x14"+1,"#x15"+1,\
  1905.    "#x16"+1,"#x17"+1,"#x18"+1,"#x19"+1,"#x20"+1,"#x21"+1,"#x22"+1,"#x23"+1,\
  1906.    "#x24"+1,"#x25"+1,"#x26"+1,"#x27"+1,"#x28"+1,"#x29"+1,"#x30"+1,"#x31"+1}
  1907.  
  1908. /* Define additional names for use in asm clobbers and asm declarations.
  1909.  
  1910.    We define the fake Condition Code register as an alias for reg 0 (which
  1911.    is our `condition code' register), so that condition codes can easily
  1912.    be clobbered by an asm.  The carry bit in the PSR is now used.  */
  1913.  
  1914. #define ADDITIONAL_REGISTER_NAMES    {"psr", 0, "cc", 0}
  1915.  
  1916. /* How to renumber registers for dbx and gdb.  */
  1917. #define DBX_REGISTER_NUMBER(REGNO) (REGNO)
  1918.  
  1919. /* Tell when to declare ASM names.  Override svr4.h to provide this hook.  */
  1920. #undef    DECLARE_ASM_NAME
  1921. #define DECLARE_ASM_NAME TARGET_SVR4
  1922.  
  1923. /* Write the extra assembler code needed to declare a function properly.  */
  1924. #undef    ASM_DECLARE_FUNCTION_NAME
  1925. #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL)            \
  1926.   do {                                    \
  1927.     if (DECLARE_ASM_NAME)                        \
  1928.       {                                    \
  1929.     fprintf (FILE, "\t%s\t ", TYPE_ASM_OP);                \
  1930.     assemble_name (FILE, NAME);                    \
  1931.     putc (',', FILE);                        \
  1932.     fprintf (FILE, TYPE_OPERAND_FMT, "function");            \
  1933.     putc ('\n', FILE);                        \
  1934.       }                                    \
  1935.     ASM_OUTPUT_LABEL(FILE, NAME);                    \
  1936.   } while (0)
  1937.  
  1938. /* Write the extra assembler code needed to declare an object properly.  */
  1939. #undef    ASM_DECLARE_OBJECT_NAME
  1940. #define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL)                \
  1941.   do {                                        \
  1942.     if (DECLARE_ASM_NAME)                            \
  1943.       {                                        \
  1944.     fprintf (FILE, "\t%s\t ", TYPE_ASM_OP);                    \
  1945.     assemble_name (FILE, NAME);                        \
  1946.     putc (',', FILE);                            \
  1947.     fprintf (FILE, TYPE_OPERAND_FMT, "object");                \
  1948.     putc ('\n', FILE);                            \
  1949.         size_directive_output = 0;                        \
  1950.     if (!flag_inhibit_size_directive && DECL_SIZE (DECL))            \
  1951.       {                                    \
  1952.             size_directive_output = 1;                        \
  1953.         fprintf (FILE, "\t%s\t ", SIZE_ASM_OP);                \
  1954.         assemble_name (FILE, NAME);                        \
  1955.         fprintf (FILE, ",%d\n",  int_size_in_bytes (TREE_TYPE (DECL))); \
  1956.       }                                    \
  1957.       }                                        \
  1958.     ASM_OUTPUT_LABEL(FILE, NAME);                        \
  1959.   } while (0)
  1960.  
  1961. /* Output the size directive for a decl in rest_of_decl_compilation
  1962.    in the case where we did not do so before the initializer.
  1963.    Once we find the error_mark_node, we know that the value of
  1964.    size_directive_output was set
  1965.    by ASM_DECLARE_OBJECT_NAME when it was run for the same decl.  */
  1966.  
  1967. #undef ASM_FINISH_DECLARE_OBJECT
  1968. #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END)     \
  1969. do {                                     \
  1970.      char *name = XSTR (XEXP (DECL_RTL (DECL), 0), 0);             \
  1971.      if (!flag_inhibit_size_directive && DECL_SIZE (DECL)         \
  1972.      && DECLARE_ASM_NAME                         \
  1973.          && ! AT_END && TOP_LEVEL                     \
  1974.      && DECL_INITIAL (DECL) == error_mark_node             \
  1975.      && !size_directive_output)                     \
  1976.        {                                 \
  1977.      size_directive_output = 1;                     \
  1978.      fprintf (FILE, "\t%s\t ", SIZE_ASM_OP);             \
  1979.      assemble_name (FILE, name);                     \
  1980.      fprintf (FILE, ",%d\n",  int_size_in_bytes (TREE_TYPE (DECL))); \
  1981.        }                                 \
  1982.    } while (0)
  1983.  
  1984. /* This is how to declare the size of a function.  */
  1985. #undef    ASM_DECLARE_FUNCTION_SIZE
  1986. #define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL)            \
  1987.   do {                                    \
  1988.     if (DECLARE_ASM_NAME)                        \
  1989.       {                                    \
  1990.     if (!flag_inhibit_size_directive)                \
  1991.       {                                \
  1992.         char label[256];                        \
  1993.         static int labelno = 0;                    \
  1994.         labelno++;                            \
  1995.         ASM_GENERATE_INTERNAL_LABEL (label, "Lfe", labelno);    \
  1996.         ASM_OUTPUT_INTERNAL_LABEL (FILE, "Lfe", labelno);        \
  1997.         fprintf (FILE, "\t%s\t ", SIZE_ASM_OP);            \
  1998.         assemble_name (FILE, (FNAME));                \
  1999.         fprintf (FILE, ",%s-", &label[1]);                \
  2000.         assemble_name (FILE, (FNAME));                \
  2001.         putc ('\n', FILE);                        \
  2002.       }                                \
  2003.       }                                    \
  2004.   } while (0)
  2005.  
  2006. /* This is how to output the definition of a user-level label named NAME,
  2007.    such as the label on a static function or variable NAME.  */
  2008. #define ASM_OUTPUT_LABEL(FILE,NAME)    \
  2009.   do { assemble_name (FILE, NAME); fputs (":\n", FILE); } while (0)
  2010.  
  2011. /* This is how to output a command to make the user-level label named NAME
  2012.    defined for reference from other files.  */
  2013. #define ASM_GLOBALIZE_LABEL(FILE,NAME)            \
  2014.   do {                            \
  2015.     fprintf (FILE, "\t%s\t ", GLOBAL_ASM_OP);        \
  2016.     assemble_name (FILE, NAME);                \
  2017.     putc ('\n', FILE);                    \
  2018.   } while (0)
  2019.  
  2020. /* This is how to output a reference to a user-level label named NAME.
  2021.    Override svr[34].h.  */
  2022. #undef    ASM_OUTPUT_LABELREF
  2023. #define ASM_OUTPUT_LABELREF(FILE,NAME)            \
  2024.   {                            \
  2025.     if (!TARGET_NO_UNDERSCORES && !TARGET_SVR4)     \
  2026.       fputc ('_', FILE);                \
  2027.     fputs (NAME, FILE);                    \
  2028.   }
  2029.  
  2030. /* This is how to output an internal numbered label where
  2031.    PREFIX is the class of label and NUM is the number within the class.
  2032.    For V.4, labels use `.' rather than `@'.  */
  2033.  
  2034. #undef ASM_OUTPUT_INTERNAL_LABEL
  2035. #ifdef AS_BUG_DOT_LABELS /* The assembler requires a declaration of local.  */
  2036. #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM)            \
  2037.   fprintf (FILE, TARGET_SVR4 ? ".%s%d:\n\t%s\t .%s%d\n" : "@%s%d:\n", \
  2038.        PREFIX, NUM, INTERNAL_ASM_OP, PREFIX, NUM)
  2039. #else
  2040. #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM)            \
  2041.   fprintf (FILE, TARGET_SVR4 ? ".%s%d:\n" : "@%s%d:\n", PREFIX, NUM)
  2042. #endif /* AS_BUG_DOT_LABELS */
  2043.  
  2044. /* This is how to store into the string LABEL
  2045.    the symbol_ref name of an internal numbered label where
  2046.    PREFIX is the class of label and NUM is the number within the class.
  2047.    This is suitable for output with `assemble_name'.  This must agree
  2048.    with ASM_OUTPUT_INTERNAL_LABEL above, except for being prefixed
  2049.    with an `*'.  */
  2050.  
  2051. #undef ASM_GENERATE_INTERNAL_LABEL
  2052. #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM)            \
  2053.   sprintf (LABEL, TARGET_SVR4 ? "*.%s%d" : "*@%s%d", PREFIX, NUM)
  2054.  
  2055. /* Internal macro to get a single precision floating point value into
  2056.    an int, so we can print it's value in hex.  */
  2057. #define FLOAT_TO_INT_INTERNAL( FVALUE, IVALUE )                \
  2058.   { union {                                \
  2059.       REAL_VALUE_TYPE d;                        \
  2060.       struct {                                \
  2061.     unsigned sign      :  1;                    \
  2062.     unsigned exponent1 :  1;                    \
  2063.     unsigned exponent2 :  3;                    \
  2064.     unsigned exponent3 :  7;                    \
  2065.     unsigned mantissa1 : 20;                    \
  2066.     unsigned mantissa2 :  3;                    \
  2067.     unsigned mantissa3 : 29;                    \
  2068.       } s;                                \
  2069.     } _u;                                \
  2070.                                     \
  2071.     union {                                \
  2072.       int i;                                \
  2073.       struct {                                \
  2074.         unsigned sign      :  1;                    \
  2075.     unsigned exponent1 :  1;                    \
  2076.     unsigned exponent3 :  7;                    \
  2077.         unsigned mantissa1 : 20;                    \
  2078.         unsigned mantissa2 :  3;                    \
  2079.       } s;                                \
  2080.     } _u2;                                \
  2081.                                     \
  2082.     _u.d = REAL_VALUE_TRUNCATE (SFmode, FVALUE);            \
  2083.     _u2.s.sign = _u.s.sign;                        \
  2084.     _u2.s.exponent1 = _u.s.exponent1;                    \
  2085.     _u2.s.exponent3 = _u.s.exponent3;                    \
  2086.     _u2.s.mantissa1 = _u.s.mantissa1;                    \
  2087.     _u2.s.mantissa2 = _u.s.mantissa2;                    \
  2088.     IVALUE = _u2.i;                            \
  2089.   }
  2090.  
  2091. /* This is how to output an assembler line defining a `double' constant.
  2092.    Use "word" pseudos to avoid printing NaNs, infinity, etc.  */
  2093. #define ASM_OUTPUT_DOUBLE(FILE,VALUE)                    \
  2094.   do {                                    \
  2095.     union { REAL_VALUE_TYPE d; long l[2]; } x;                \
  2096.     x.d = (VALUE);                            \
  2097.     fprintf (FILE, "\t%s\t 0x%.8x, 0x%.8x\n", INT_ASM_OP,            \
  2098.          x.l[0], x.l[1]);                        \
  2099.   } while (0)
  2100.  
  2101. /* This is how to output an assembler line defining a `float' constant.  */
  2102. #define ASM_OUTPUT_FLOAT(FILE,VALUE)                    \
  2103.   do {                                    \
  2104.     int i;                                \
  2105.     FLOAT_TO_INT_INTERNAL (VALUE, i);                    \
  2106.     fprintf (FILE, "\t%s\t 0x%.8x\n", INT_ASM_OP, i);            \
  2107.   } while (0)
  2108.  
  2109. /* Likewise for `int', `short', and `char' constants.  */
  2110. #define ASM_OUTPUT_INT(FILE,VALUE)                    \
  2111. ( fprintf (FILE, "\t%s\t ", INT_ASM_OP),                \
  2112.   output_addr_const (FILE, (VALUE)),                    \
  2113.   fprintf (FILE, "\n"))
  2114.  
  2115. #define ASM_OUTPUT_SHORT(FILE,VALUE)                    \
  2116. ( fprintf (FILE, "\t%s\t ", SHORT_ASM_OP),                \
  2117.   output_addr_const (FILE, (VALUE)),                    \
  2118.   fprintf (FILE, "\n"))
  2119.  
  2120. #define ASM_OUTPUT_CHAR(FILE,VALUE)                    \
  2121. ( fprintf (FILE, "\t%s\t ", CHAR_ASM_OP),                \
  2122.   output_addr_const (FILE, (VALUE)),                    \
  2123.   fprintf (FILE, "\n"))
  2124.  
  2125. /* This is how to output an assembler line for a numeric constant byte.  */
  2126. #define ASM_OUTPUT_BYTE(FILE,VALUE)  \
  2127.   fprintf (FILE, "\t%s\t 0x%x\n", CHAR_ASM_OP, (VALUE))
  2128.  
  2129. /* The single-byte pseudo-op is the default.  Override svr[34].h.  */
  2130. #undef    ASM_BYTE_OP
  2131. #define ASM_BYTE_OP "byte"
  2132. #undef    ASM_OUTPUT_ASCII
  2133. #define ASM_OUTPUT_ASCII(FILE, P, SIZE)  \
  2134.   output_ascii (FILE, ASCII_DATA_ASM_OP, 48, P, SIZE)
  2135.  
  2136. /* Override svr4.h.  Change to the readonly data section for a table of
  2137.    addresses.  final_scan_insn changes back to the text section.  */
  2138. #undef    ASM_OUTPUT_CASE_LABEL
  2139. #define ASM_OUTPUT_CASE_LABEL(FILE, PREFIX, NUM, TABLE)            \
  2140.   do {                                    \
  2141.     if (! CASE_VECTOR_INSNS)                        \
  2142.       {                                    \
  2143.         readonly_data_section ();                    \
  2144.         ASM_OUTPUT_ALIGN (FILE, 2);                    \
  2145.       }                                    \
  2146.     ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM);            \
  2147.   } while (0)
  2148.  
  2149. /* Epilogue for case labels.  This jump instruction is called by casesi
  2150.    to transfer to the appropriate branch instruction within the table.
  2151.    The label `@L<n>e' is coined to mark the end of the table.  */
  2152. #define ASM_OUTPUT_CASE_END(FILE, NUM, TABLE)                \
  2153.   do {                                    \
  2154.     if (CASE_VECTOR_INSNS)                        \
  2155.       {                                    \
  2156.     char label[256];                         \
  2157.     ASM_GENERATE_INTERNAL_LABEL (label, "L", NUM);            \
  2158.     fprintf (FILE, "%se:\n", &label[1]);                \
  2159.     if (! flag_delayed_branch)                    \
  2160.       fprintf (FILE, "\tlda\t %s,%s[%s]\n", reg_names[1],        \
  2161.            reg_names[1], reg_names[m88k_case_index]);        \
  2162.     fprintf (FILE, "\tjmp\t %s\n", reg_names[1]);            \
  2163.       }                                    \
  2164.   } while (0)
  2165.  
  2166. /* This is how to output an element of a case-vector that is absolute.  */
  2167. #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)                \
  2168.   do {                                    \
  2169.     char buffer[256];                            \
  2170.     ASM_GENERATE_INTERNAL_LABEL (buffer, "L", VALUE);            \
  2171.     fprintf (FILE, CASE_VECTOR_INSNS ? "\tbr\t %s\n" : "\tword\t %s\n",    \
  2172.          &buffer[1]);                        \
  2173.   } while (0)
  2174.  
  2175. /* This is how to output an element of a case-vector that is relative.  */
  2176. #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) \
  2177.   ASM_OUTPUT_ADDR_VEC_ELT (FILE, VALUE)
  2178.  
  2179. /* This is how to output an assembler line
  2180.    that says to advance the location counter
  2181.    to a multiple of 2**LOG bytes.  */
  2182. #define ASM_OUTPUT_ALIGN(FILE,LOG)    \
  2183.   if ((LOG) != 0)            \
  2184.     fprintf (FILE, "\t%s\t %d\n", ALIGN_ASM_OP, 1<<(LOG))
  2185.  
  2186. /* On the m88100, align the text address to half a cache boundary when it
  2187.    can only be reached by jumping.  Pack code tightly when compiling
  2188.    crtstuff.c.  */
  2189. #define ASM_OUTPUT_ALIGN_CODE(FILE) \
  2190.   ASM_OUTPUT_ALIGN (FILE, \
  2191.             (TARGET_88100 && !flag_inhibit_size_directive ? 3 : 2))
  2192.  
  2193. /* Override svr[34].h.  */
  2194. #undef    ASM_OUTPUT_SKIP
  2195. #define ASM_OUTPUT_SKIP(FILE,SIZE)  \
  2196.   fprintf (FILE, "\t%s\t %u\n", SKIP_ASM_OP, (SIZE))
  2197.  
  2198. /* Override svr4.h.  */
  2199. #undef    ASM_OUTPUT_EXTERNAL_LIBCALL
  2200.  
  2201. /* This says how to output an assembler line to define a global common
  2202.    symbol.  Size can be zero for the unusual case of a `struct { int : 0; }'.
  2203.    Override svr[34].h.  */
  2204. #undef    ASM_OUTPUT_COMMON
  2205. #undef    ASM_OUTPUT_ALIGNED_COMMON
  2206. #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED)    \
  2207. ( fprintf ((FILE), "\t%s\t ",                \
  2208.        ((SIZE) ? (SIZE) : 1) <= m88k_gp_threshold ? SCOMM_ASM_OP : COMMON_ASM_OP), \
  2209.   assemble_name ((FILE), (NAME)),            \
  2210.   fprintf ((FILE), ",%u\n", (SIZE) ? (SIZE) : 1))
  2211.  
  2212. /* This says how to output an assembler line to define a local common
  2213.    symbol.  Override svr[34].h.  */
  2214. #undef    ASM_OUTPUT_LOCAL
  2215. #undef    ASM_OUTPUT_ALIGNED_LOCAL
  2216. #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED)    \
  2217. ( fprintf ((FILE), "\t%s\t ",                \
  2218.        ((SIZE) ? (SIZE) : 1) <= m88k_gp_threshold ? SBSS_ASM_OP : BSS_ASM_OP), \
  2219.   assemble_name ((FILE), (NAME)),            \
  2220.   fprintf ((FILE), ",%u,%d\n", (SIZE) ? (SIZE) : 1, (SIZE) <= 4 ? 4 : 8))
  2221.  
  2222. /* Store in OUTPUT a string (made with alloca) containing
  2223.    an assembler-name for a local static variable named NAME.
  2224.    LABELNO is an integer which is different for each call.  */
  2225. #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)    \
  2226. ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10),    \
  2227.   sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO)))
  2228.  
  2229. /* This is how to output an insn to push a register on the stack.
  2230.    It need not be very fast code.  */
  2231. #define ASM_OUTPUT_REG_PUSH(FILE,REGNO)  \
  2232.   fprintf (FILE, "\tsubu\t %s,%s,%d\n\tst\t %s,%s,0\n",    \
  2233.        reg_names[STACK_POINTER_REGNUM],        \
  2234.        reg_names[STACK_POINTER_REGNUM],        \
  2235.        (STACK_BOUNDARY / BITS_PER_UNIT),        \
  2236.        reg_names[REGNO],                \
  2237.        reg_names[STACK_POINTER_REGNUM])
  2238.  
  2239. /* Length in instructions of the code output by ASM_OUTPUT_REG_PUSH.  */
  2240. #define REG_PUSH_LENGTH 2
  2241.  
  2242. /* This is how to output an insn to pop a register from the stack.  */
  2243. #define ASM_OUTPUT_REG_POP(FILE,REGNO)  \
  2244.   fprintf (FILE, "\tld\t %s,%s,0\n\taddu\t %s,%s,%d\n",    \
  2245.        reg_names[REGNO],                \
  2246.        reg_names[STACK_POINTER_REGNUM],        \
  2247.        reg_names[STACK_POINTER_REGNUM],        \
  2248.        reg_names[STACK_POINTER_REGNUM],        \
  2249.        (STACK_BOUNDARY / BITS_PER_UNIT))
  2250.  
  2251. /* Length in instructions of the code output by ASM_OUTPUT_REG_POP.  */
  2252. #define REG_POP_LENGTH 2
  2253.  
  2254. /* Define the parentheses used to group arithmetic operations
  2255.    in assembler code.  */
  2256. #define ASM_OPEN_PAREN "("
  2257. #define ASM_CLOSE_PAREN ")"
  2258.  
  2259. /* Define results of standard character escape sequences.  */
  2260. #define TARGET_BELL 007
  2261. #define TARGET_BS 010
  2262. #define TARGET_TAB 011
  2263. #define TARGET_NEWLINE 012
  2264. #define TARGET_VT 013
  2265. #define TARGET_FF 014
  2266. #define TARGET_CR 015
  2267.  
  2268. /* Macros to deal with OCS debug information */
  2269.  
  2270. #define OCS_START_PREFIX    "Ltb"
  2271. #define OCS_END_PREFIX        "Lte"
  2272.  
  2273. #define PUT_OCS_FUNCTION_START(FILE) \
  2274.   { ASM_OUTPUT_INTERNAL_LABEL (FILE, OCS_START_PREFIX, m88k_function_number); }
  2275.  
  2276. #define PUT_OCS_FUNCTION_END(FILE) \
  2277.   { ASM_OUTPUT_INTERNAL_LABEL (FILE, OCS_END_PREFIX, m88k_function_number); }
  2278.  
  2279. /* Macros for debug information */
  2280. #define DEBUGGER_AUTO_OFFSET(X) \
  2281.   (m88k_debugger_offset (X, 0) \
  2282.    + (TARGET_OCS_FRAME_POSITION ? 0 : m88k_stack_size - m88k_fp_offset))
  2283.  
  2284. #define DEBUGGER_ARG_OFFSET(OFFSET, X) \
  2285.   (m88k_debugger_offset (X, OFFSET) \
  2286.    + (TARGET_OCS_FRAME_POSITION ? 0 : m88k_stack_size - m88k_fp_offset))
  2287.  
  2288. /* Macros to deal with SDB debug information */
  2289. #ifdef SDB_DEBUGGING_INFO
  2290.  
  2291. /* Output structure tag names even when it causes a forward reference. */
  2292. #define SDB_ALLOW_FORWARD_REFERENCES
  2293.  
  2294. /* Print out extra debug information in the assembler file */
  2295. #define PUT_SDB_SCL(a)                        \
  2296.   do {                                \
  2297.     register int s = (a);                    \
  2298.     register char *scl;                        \
  2299.     switch (s)                            \
  2300.       {                                \
  2301.       case C_EFCN:    scl = "end of function";    break;    \
  2302.       case C_NULL:    scl = "NULL storage class";    break;    \
  2303.       case C_AUTO:    scl = "automatic";        break;    \
  2304.       case C_EXT:    scl = "external";        break;    \
  2305.       case C_STAT:    scl = "static";            break;    \
  2306.       case C_REG:    scl = "register";        break;    \
  2307.       case C_EXTDEF:    scl = "external definition";    break;    \
  2308.       case C_LABEL:    scl = "label";            break;    \
  2309.       case C_ULABEL:    scl = "undefined label";    break;    \
  2310.       case C_MOS:    scl = "structure member";    break;    \
  2311.       case C_ARG:    scl = "argument";        break;    \
  2312.       case C_STRTAG:    scl = "structure tag";        break;    \
  2313.       case C_MOU:    scl = "union member";        break;    \
  2314.       case C_UNTAG:    scl = "union tag";        break;    \
  2315.       case C_TPDEF:    scl = "typedef";        break;    \
  2316.       case C_USTATIC:    scl = "uninitialized static";    break;    \
  2317.       case C_ENTAG:    scl = "enumeration tag";    break;    \
  2318.       case C_MOE:    scl = "member of enumeration";    break;    \
  2319.       case C_REGPARM:    scl = "register parameter";    break;    \
  2320.       case C_FIELD:    scl = "bit field";        break;    \
  2321.       case C_BLOCK:    scl = "block start/end";    break;    \
  2322.       case C_FCN:    scl = "function start/end";    break;    \
  2323.       case C_EOS:    scl = "end of structure";    break;    \
  2324.       case C_FILE:    scl = "filename";        break;    \
  2325.       case C_LINE:    scl = "line";            break;    \
  2326.       case C_ALIAS:    scl = "duplicated tag";        break;    \
  2327.       case C_HIDDEN:    scl = "hidden";            break;    \
  2328.       default:        scl = "unknown";        break;    \
  2329.       }                                \
  2330.                                 \
  2331.     fprintf(asm_out_file, "\tscl\t %d\t\t\t\t; %s\n", s, scl);    \
  2332.   } while (0)
  2333.  
  2334. #define PUT_SDB_TYPE(a)                        \
  2335.   do {                                \
  2336.     register int t = (a);                    \
  2337.     static char buffer[100];                    \
  2338.     register char *p = buffer, *q;                \
  2339.     register int typ = t;                    \
  2340.     register int i,d;                        \
  2341.                                 \
  2342.     for (i = 0; i <= 5; i++)                    \
  2343.       {                                \
  2344.     switch ((typ >> ((i*N_TSHIFT) + N_BTSHFT)) & 03)    \
  2345.       {                            \
  2346.       case DT_PTR:                        \
  2347.         strcpy (p, "ptr to ");                \
  2348.         p += sizeof("ptr to");                \
  2349.         break;                        \
  2350.                                 \
  2351.       case DT_ARY:                        \
  2352.         strcpy (p, "array of ");                \
  2353.         p += sizeof("array of");                \
  2354.         break;                        \
  2355.                                 \
  2356.       case DT_FCN:                        \
  2357.         strcpy (p, "func ret ");                \
  2358.         p += sizeof("func ret");                \
  2359.         break;                        \
  2360.       }                            \
  2361.       }                                \
  2362.                                 \
  2363.   switch (typ & N_BTMASK)                    \
  2364.     {                                \
  2365.     case T_NULL:    q = "<no type>";    break;        \
  2366.     case T_CHAR:    q = "char";        break;        \
  2367.     case T_SHORT:    q = "short";        break;        \
  2368.     case T_INT:        q = "int";        break;        \
  2369.     case T_LONG:    q = "long";        break;        \
  2370.     case T_FLOAT:    q = "float";        break;        \
  2371.     case T_DOUBLE:    q = "double";        break;        \
  2372.     case T_STRUCT:    q = "struct";        break;        \
  2373.     case T_UNION:    q = "union";        break;        \
  2374.     case T_ENUM:    q = "enum";        break;        \
  2375.     case T_MOE:        q = "enum member";    break;        \
  2376.     case T_UCHAR:    q = "unsigned char";    break;        \
  2377.     case T_USHORT:    q = "unsigned short";    break;        \
  2378.     case T_UINT:    q = "unsigned int";    break;        \
  2379.     case T_ULONG:    q = "unsigned long";    break;        \
  2380.     default:        q = "void";        break;        \
  2381.     }                                \
  2382.                                 \
  2383.     strcpy (p, q);                        \
  2384.     fprintf(asm_out_file, "\ttype\t %d\t\t\t\t; %s\n",        \
  2385.         t, buffer);                        \
  2386.   } while (0)
  2387.  
  2388. #define PUT_SDB_INT_VAL(a) \
  2389.   fprintf (asm_out_file, "\tval\t %d\n", (a))
  2390.  
  2391. #define PUT_SDB_VAL(a)                    \
  2392. ( fprintf (asm_out_file, "\tval\t "),            \
  2393.   output_addr_const (asm_out_file, (a)),        \
  2394.   fputc ('\n', asm_out_file))
  2395.  
  2396. #define PUT_SDB_DEF(a)                        \
  2397.   do { fprintf (asm_out_file, "\tsdef\t ");            \
  2398.     ASM_OUTPUT_LABELREF (asm_out_file, a);            \
  2399.     fputc ('\n', asm_out_file);                    \
  2400.   } while (0)
  2401.  
  2402. #define PUT_SDB_PLAIN_DEF(a) \
  2403.   fprintf(asm_out_file,"\tsdef\t .%s\n", a)
  2404.  
  2405. /* Simply and endef now.  */
  2406. #define PUT_SDB_ENDEF \
  2407.   fputs("\tendef\n\n", asm_out_file)
  2408.  
  2409. #define PUT_SDB_SIZE(a) \
  2410.   fprintf (asm_out_file, "\tsize\t %d\n", (a))
  2411.  
  2412. /* Max dimensions to store for debug information (limited by COFF).  */
  2413. #define SDB_MAX_DIM 6
  2414.  
  2415. /* New method for dim operations.  */
  2416. #define PUT_SDB_START_DIM \
  2417.   fputs("\tdim\t ", asm_out_file)
  2418.  
  2419. /* How to end the DIM sequence.  */
  2420. #define PUT_SDB_LAST_DIM(a) \
  2421.   fprintf(asm_out_file, "%d\n", a)
  2422.  
  2423. #define PUT_SDB_TAG(a)                        \
  2424.   do {                                \
  2425.     fprintf (asm_out_file, "\ttag\t ");                \
  2426.     ASM_OUTPUT_LABELREF (asm_out_file, a);            \
  2427.     fputc ('\n', asm_out_file);                    \
  2428.   } while( 0 )
  2429.  
  2430. #define PUT_SDB_BLOCK_OR_FUNCTION(NAME, SCL, LINE)        \
  2431.   do {                                \
  2432.     fprintf (asm_out_file, "\n\tsdef\t %s\n\tval\t .\n",    \
  2433.          NAME);                        \
  2434.     PUT_SDB_SCL( SCL );                        \
  2435.     fprintf (asm_out_file, "\tline\t %d\n\tendef\n\n",        \
  2436.          (LINE));                        \
  2437.   } while (0)
  2438.  
  2439. #define PUT_SDB_BLOCK_START(LINE) \
  2440.   PUT_SDB_BLOCK_OR_FUNCTION (".bb", C_BLOCK, (LINE))
  2441.  
  2442. #define PUT_SDB_BLOCK_END(LINE) \
  2443.   PUT_SDB_BLOCK_OR_FUNCTION (".eb", C_BLOCK, (LINE))
  2444.  
  2445. #define PUT_SDB_FUNCTION_START(LINE)                \
  2446.   do {                                \
  2447.     fprintf (asm_out_file, "\tln\t 1\n");            \
  2448.     PUT_SDB_BLOCK_OR_FUNCTION (".bf", C_FCN, (LINE));        \
  2449.   } while (0)
  2450.  
  2451. #define PUT_SDB_FUNCTION_END(LINE)                \
  2452.   do {                                \
  2453.     PUT_SDB_BLOCK_OR_FUNCTION (".ef", C_FCN, (LINE));        \
  2454.   } while (0)
  2455.  
  2456. #define PUT_SDB_EPILOGUE_END(NAME)                \
  2457.   do {                                \
  2458.     text_section ();                        \
  2459.     fprintf (asm_out_file, "\n\tsdef\t ");            \
  2460.     ASM_OUTPUT_LABELREF(asm_out_file, (NAME));            \
  2461.     fputc('\n', asm_out_file);                    \
  2462.     PUT_SDB_SCL( C_EFCN );                    \
  2463.     fprintf (asm_out_file, "\tendef\n\n");            \
  2464.   } while (0)
  2465.  
  2466. #define SDB_GENERATE_FAKE(BUFFER, NUMBER) \
  2467.   sprintf ((BUFFER), ".%dfake", (NUMBER));
  2468.  
  2469. #endif /* SDB_DEBUGGING_INFO */
  2470.  
  2471. /* Support const and tdesc sections.  Generally, a const section will
  2472.    be distinct from the text section whenever we do V.4-like things
  2473.    and so follows DECLARE_ASM_NAME.  Note that strings go in text
  2474.    rather than const.  Override svr[34].h.  */
  2475.  
  2476. #undef    USE_CONST_SECTION
  2477. #undef    EXTRA_SECTIONS
  2478.  
  2479. #define USE_CONST_SECTION DECLARE_ASM_NAME
  2480.  
  2481. #if defined(USING_SVR4_H)
  2482.  
  2483. #define EXTRA_SECTIONS in_const, in_tdesc, in_sdata, in_ctors, in_dtors
  2484. #define INIT_SECTION_FUNCTION
  2485. #define FINI_SECTION_FUNCTION
  2486.  
  2487. #else
  2488. #if defined(USING_SVR3_H)
  2489.  
  2490. #define EXTRA_SECTIONS in_const, in_tdesc, in_sdata, in_ctors, in_dtors, \
  2491.                in_init, in_fini
  2492.  
  2493. #else /* luna or other not based on svr[34].h.  */
  2494.  
  2495. #undef INIT_SECTION_ASM_OP
  2496. #define EXTRA_SECTIONS in_const, in_tdesc, in_sdata
  2497. #define CONST_SECTION_FUNCTION                        \
  2498. void                                    \
  2499. const_section ()                            \
  2500. {                                    \
  2501.   text_section();                            \
  2502. }
  2503. #define CTORS_SECTION_FUNCTION
  2504. #define DTORS_SECTION_FUNCTION
  2505. #define INIT_SECTION_FUNCTION
  2506. #define FINI_SECTION_FUNCTION
  2507.  
  2508. #endif /* USING_SVR3_H */
  2509. #endif /* USING_SVR4_H */
  2510.  
  2511. #undef    EXTRA_SECTION_FUNCTIONS
  2512. #define EXTRA_SECTION_FUNCTIONS                        \
  2513.   CONST_SECTION_FUNCTION                        \
  2514.                                     \
  2515. void                                    \
  2516. tdesc_section ()                            \
  2517. {                                    \
  2518.   if (in_section != in_tdesc)                        \
  2519.     {                                    \
  2520.       fprintf (asm_out_file, "%s\n", TDESC_SECTION_ASM_OP);        \
  2521.       in_section = in_tdesc;                        \
  2522.     }                                    \
  2523. }                                    \
  2524.                                     \
  2525. void                                    \
  2526. sdata_section ()                            \
  2527. {                                    \
  2528.   if (in_section != in_sdata)                        \
  2529.     {                                    \
  2530.       fprintf (asm_out_file, "%s\n", SDATA_SECTION_ASM_OP);        \
  2531.       in_section = in_sdata;                        \
  2532.     }                                    \
  2533. }                                    \
  2534.                                     \
  2535.   CTORS_SECTION_FUNCTION                        \
  2536.   DTORS_SECTION_FUNCTION                        \
  2537.   INIT_SECTION_FUNCTION                            \
  2538.   FINI_SECTION_FUNCTION
  2539.  
  2540. /* A C statement or statements to switch to the appropriate
  2541.    section for output of DECL.  DECL is either a `VAR_DECL' node
  2542.    or a constant of some sort.  RELOC indicates whether forming
  2543.    the initial value of DECL requires link-time relocations.
  2544.  
  2545.    For strings, the section is selected before the segment info is encoded.  */
  2546. #undef    SELECT_SECTION
  2547. #define SELECT_SECTION(DECL,RELOC)                    \
  2548. {                                    \
  2549.   if (TREE_CODE (DECL) == STRING_CST)                    \
  2550.     {                                    \
  2551.       if (! flag_writable_strings)                    \
  2552.     const_section ();                        \
  2553.       else if ( TREE_STRING_LENGTH (DECL) <= m88k_gp_threshold)        \
  2554.     sdata_section ();                        \
  2555.       else                                \
  2556.     data_section ();                        \
  2557.     }                                    \
  2558.   else if (TREE_CODE (DECL) == VAR_DECL)                \
  2559.     {                                    \
  2560.       if (SYMBOL_REF_FLAG (XEXP (DECL_RTL (DECL), 0)))            \
  2561.     sdata_section ();                        \
  2562.       else if ((flag_pic && RELOC)                    \
  2563.            || !TREE_READONLY (DECL) || TREE_SIDE_EFFECTS (DECL)    \
  2564.            || !DECL_INITIAL (DECL)                    \
  2565.            || (DECL_INITIAL (DECL) != error_mark_node        \
  2566.            && !TREE_CONSTANT (DECL_INITIAL (DECL))))        \
  2567.     data_section ();                        \
  2568.       else                                \
  2569.     const_section ();                        \
  2570.     }                                    \
  2571.   else                                    \
  2572.     const_section ();                            \
  2573. }
  2574.  
  2575. /* Jump tables consist of branch instructions and should be output in
  2576.    the text section.  When we use a table of addresses, we explicitly
  2577.    change to the readonly data section.  */
  2578. #define JUMP_TABLES_IN_TEXT_SECTION 1
  2579.  
  2580. /* Define this macro if references to a symbol must be treated differently
  2581.    depending on something about the variable or function named by the
  2582.    symbol (such as what section it is in).
  2583.  
  2584.    The macro definition, if any, is executed immediately after the rtl for
  2585.    DECL has been created and stored in `DECL_RTL (DECL)'.  The value of the
  2586.    rtl will be a `mem' whose address is a `symbol_ref'.
  2587.  
  2588.    For the m88k, determine if the item should go in the global pool.  */
  2589. #define ENCODE_SECTION_INFO(DECL)                    \
  2590.   do {                                    \
  2591.     if (m88k_gp_threshold > 0)                        \
  2592.       if (TREE_CODE (DECL) == VAR_DECL)                    \
  2593.     {                                \
  2594.       if (!TREE_READONLY (DECL) || TREE_SIDE_EFFECTS (DECL))    \
  2595.         {                                \
  2596.           int size = int_size_in_bytes (TREE_TYPE (DECL));        \
  2597.                                     \
  2598.           if (size > 0 && size <= m88k_gp_threshold)        \
  2599.         SYMBOL_REF_FLAG (XEXP (DECL_RTL (DECL), 0)) = 1;    \
  2600.         }                                \
  2601.     }                                \
  2602.       else if (TREE_CODE (DECL) == STRING_CST                \
  2603.            && flag_writable_strings                    \
  2604.            && TREE_STRING_LENGTH (DECL) <= m88k_gp_threshold)    \
  2605.     SYMBOL_REF_FLAG (XEXP (TREE_CST_RTL (DECL), 0)) = 1;        \
  2606.   } while (0)
  2607.  
  2608. /* Print operand X (an rtx) in assembler syntax to file FILE.
  2609.    CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
  2610.    For `%' followed by punctuation, CODE is the punctuation and X is null.  */
  2611. #define PRINT_OPERAND_PUNCT_VALID_P(c) \
  2612.   ((c) == '#' || (c) == '.' || (c) == '!' || (c) == '*' || (c) == ';')
  2613.  
  2614. #define PRINT_OPERAND(FILE, X, CODE) print_operand (FILE, X, CODE)
  2615.  
  2616. /* Print a memory address as an operand to reference that memory location.  */
  2617. #define PRINT_OPERAND_ADDRESS(FILE, ADDR) print_operand_address (FILE, ADDR)
  2618.  
  2619. /* This says not to strength reduce the addr calculations within loops
  2620.    (otherwise it does not take advantage of m88k scaled loads and stores */
  2621.  
  2622. #define DONT_REDUCE_ADDR
  2623.